Example #1
0
    def __init__(self, parent=None):
        super(XOverlayWizardPage, self).__init__(parent)

        self.setFrameShape(QtGui.QFrame.Box)

        # define custom properties
        self._commitPage = False
        self._finalPage = False
        self._retryEnabled = False
        self._nextId = None

        # create the title information
        font = self.font()
        font.setBold(True)
        base_size = font.pointSize()
        font.setPointSize(base_size + 4)

        # set the palette coloring
        pal = self.palette()
        pal.setColor(pal.WindowText, QtGui.QColor('white'))
        self.setPalette(pal)

        # create the title labels
        self._titleLabel = QtGui.QLabel('', self)
        self._titleLabel.setFont(font)
        self._titleLabel.setPalette(pal)
        font.setPointSize(base_size + 2)
        self._subTitleLabel = QtGui.QLabel('', self)
        self._subTitleLabel.setPalette(pal)

        self.adjustMargins()
Example #2
0
    def createMenu(self, parent):
        """
        Creates a new menu for the inputed parent item.
        
        :param      parent | <QMenu>
        """
        menu = QtGui.QMenu(parent)
        menu.setTitle('&View')

        act = menu.addAction('&Lock/Unlock Layout')
        act.setIcon(QtGui.QIcon(projexui.resources.find('img/view/lock.png')))
        act.triggered.connect(self.toggleLocked)

        menu.addSeparator()
        act = menu.addAction('&Export Layout as...')
        act.setIcon(QtGui.QIcon(
            projexui.resources.find('img/view/export.png')))
        act.triggered.connect(self.exportProfile)

        act = menu.addAction('&Import Layout from...')
        act.setIcon(QtGui.QIcon(
            projexui.resources.find('img/view/import.png')))
        act.triggered.connect(self.importProfile)

        menu.addSeparator()

        act = menu.addAction('&Clear Layout')
        act.setIcon(QtGui.QIcon(
            projexui.resources.find('img/view/remove.png')))
        act.triggered.connect(self.resetForced)

        return menu
Example #3
0
    def paintEvent(self, event):
        with XPainter(self) as painter:
            painter.fillRect(event.rect(), QtGui.QColor('lightGray'))

            edit = self.codeEditor()
            block = edit.firstVisibleBlock()
            blockNumber = block.blockNumber()
            top = edit.blockBoundingGeometry(block).translated(
                edit.contentOffset()).top()
            bottom = top + edit.blockBoundingRect(block).height()
            textHeight = edit.fontMetrics().height()

            painter.setFont(self.font())
            painter.setPen(QtGui.QColor('black'))
            while block.isValid() and top <= event.rect().bottom():
                if block.isVisible() and bottom >= event.rect().top():
                    painter.drawText(0, top,
                                     self.width() - 6,
                                     textHeight, QtCore.Qt.AlignRight,
                                     str(blockNumber + 1))

                block = block.next()
                top = bottom
                bottom = top + edit.blockBoundingRect(block).height()
                blockNumber += 1
    def drawDisplay(self, painter, option, rect, text):
        """
        Overloads the drawDisplay method to render HTML if the rich text \
        information is set to true.
        
        :param      painter | <QtGui.QPainter>
                    option  | <QtGui.QStyleOptionItem>
                    rect    | <QtCore.QRect>
                    text    | <str>
        """
        if self.showRichText():
            # create the document
            doc = QtGui.QTextDocument()
            doc.setTextWidth(float(rect.width()))
            doc.setHtml(text)

            # draw the contents
            painter.translate(rect.x(), rect.y())
            doc.drawContents(
                painter,
                QtCore.QRectF(0, 0, float(rect.width()), float(rect.height())))

            painter.translate(-rect.x(), -rect.y())
        else:
            if type(text).__name__ not in ('str', 'unicode', 'QString'):
                text = nativestring(text)

            metrics = QtGui.QFontMetrics(option.font)
            text = metrics.elidedText(
                text, QtCore.Qt.TextElideMode(option.textElideMode),
                rect.width())

            painter.setFont(option.font)
            painter.drawText(rect, int(option.displayAlignment), text)
Example #5
0
    def __init__(self, parent):
        super(XListGroupItem, self).__init__(parent)

        # define the text property
        self._text = ''
        self._expanded = True
        self._children = set()

        # define the widget for this item
        lwidget = self.listWidget()

        btn = QtGui.QToolButton(lwidget)
        btn.setAutoRaise(True)
        btn.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
        btn.setSizePolicy(QtGui.QSizePolicy.Expanding,
                          QtGui.QSizePolicy.Preferred)

        ico = 'img/treeview/triangle_down.png'
        btn.setIcon(QtGui.QIcon(resources.find(ico)))

        font = btn.font()
        font.setBold(True)
        btn.setFont(font)

        lwidget.setItemWidget(self, btn)

        # create connections
        btn.clicked.connect(self.toggle)
Example #6
0
    def __init__(self, parent=None):
        super(XOverlayWidget, self).__init__(parent)

        # define custom properties
        self._centralWidget = None
        self._result = None
        self._closable = True
        self._closeAlignment = QtCore.Qt.AlignTop | QtCore.Qt.AlignRight
        self._closeButton = XToolButton(self)
        self._closeButton.setShadowed(True)
        self._closeButton.setIcon(
            QtGui.QIcon(resources.find('img/overlay/close.png')))
        self._closeButton.setIconSize(QtCore.QSize(24, 24))
        self._closeButton.setToolTip('Close')

        # create the coloring for the overlay
        palette = self.palette()
        clr = QtGui.QColor('#222222')
        clr.setAlpha(210)
        palette.setColor(palette.Window, clr)
        self.setPalette(palette)
        self.setAutoFillBackground(True)

        # listen to the parents event filter
        parent.installEventFilter(self)

        # initialize the widget
        self.hide()
        self.move(0, 0)
        self.resize(parent.size())
        self._closeButton.clicked.connect(self.reject)
Example #7
0
    def updateUi(self):
        if self.uiRecordBTN.isChecked():
            ico = resources.find('img/debug/break.png')
            clr = QtGui.QColor('red')
            self.uiRecordBTN.blink(True)
        else:
            ico = resources.find('img/debug/continue.png')
            clr = QtGui.QColor('blue')
            self.uiRecordBTN.blink(False)

        self.uiRecordBTN.setIcon(QtGui.QIcon(ico))
        palette = self.uiRecordBTN.palette()
        palette.setColor(palette.Shadow, clr)
        self.uiRecordBTN.setPalette(palette)
Example #8
0
    def initGroupStyle(self, useIcons=True, columnCount=None):
        """
        Initialzes this item with a grouping style option.
        """
        flags      = self.flags()
        if flags & QtCore.Qt.ItemIsSelectable:
            flags ^= QtCore.Qt.ItemIsSelectable
            self.setFlags(flags)
        
        if useIcons:
            ico        = QtGui.QIcon(resources.find('img/treeview/triangle_right.png'))
            expand_ico = QtGui.QIcon(resources.find('img/treeview/triangle_down.png'))
            
            self.setIcon(0, ico)
            self.setExpandedIcon(0, expand_ico)
        
        palette = QtGui.QApplication.palette()
        
        line_clr = palette.color(palette.Mid)
        base_clr = palette.color(palette.Button)
        text_clr = palette.color(palette.ButtonText)
        
        gradient = QtGui.QLinearGradient()
        
        gradient.setColorAt(0.00, line_clr)
        gradient.setColorAt(0.03, line_clr)
        gradient.setColorAt(0.04, base_clr.lighter(105))
        gradient.setColorAt(0.25, base_clr)
        gradient.setColorAt(0.96, base_clr.darker(105))
        gradient.setColorAt(0.97, line_clr)
        gradient.setColorAt(1.00, line_clr)
        
        h = self._fixedHeight
        if not h:
            h = self.sizeHint(0).height()
        if not h:
            h = 18
        
        gradient.setStart(0.0, 0.0)
        gradient.setFinalStop(0.0, h)
        
        brush = QtGui.QBrush(gradient)
        
        tree = self.treeWidget()
        columnCount = columnCount or (tree.columnCount() if tree else self.columnCount())

        for i in range(columnCount):
            self.setForeground(i, text_clr)
            self.setBackground(i, brush)
Example #9
0
 def startLoading(self):
     """
     Updates this item to mark the item as loading.  This will create
     a QLabel with the loading ajax spinner to indicate that progress
     is occurring.
     """
     if self._loading:
         return False
     
     tree = self.treeWidget()
     if not tree:
         return
     
     self._loading = True
     self.setText(0, '')
     
     # create the label for this item
     lbl = QtGui.QLabel(self.treeWidget())
     lbl.setMovie(XLoaderWidget.getMovie())
     lbl.setAlignment(QtCore.Qt.AlignCenter)
     tree.setItemWidget(self, 0, lbl)
     
     try:
         tree.loadStarted.emit(self)
     except AttributeError:
         pass
     
     return True
    def drawCheck(self, painter, option, rect, state):
        """
        Renders a check indicator within the rectangle based on the inputed \
        check state.
        
        :param      painter | <QtGui.QPainter>
                    option  | <QtGui.QStyleOptionViewItem>
                    rect    | <QtGui.QRect>
                    state   | <QtCore.Qt.CheckState>
        """
        if not self.useCheckMaps():
            return super(XTreeWidgetDelegate,
                         self).drawCheck(painter, option, rect, state)

        pixmap = None
        if state == QtCore.Qt.Checked:
            pixmap = self.checkOnMap()
        elif state == QtCore.Qt.PartiallyChecked:
            pixmap = self.checkPartialMap()
        elif state == QtCore.Qt.Unchecked:
            pixmap = self.checkOffMap()

        if type(pixmap) in (str, unicode):
            pixmap = QtGui.QPixmap(pixmap)

        if not pixmap:
            return

        x = rect.x() + (rect.width() - 16) / 2.0
        y = rect.y() + (rect.height() - 16) / 2.0

        painter.drawPixmap(int(x), int(y), pixmap)
Example #11
0
 def setUnlockIcon(self, icon):
     """
     Sets the unlock icon for this button.
     
     :param      icon | <str> || <QtGui.QIcon>
     """
     self._unlockIcon = QtGui.QIcon(icon)
Example #12
0
 def setHtml(self, column, html):
     """
     Creates a label with the given HTML for this item and column.  This
     method requires the item to be a part of the tree.
     
     :param      column | <int>
                 html   | <unicode>
     
     :return     <bool> | success
     """
     tree = self.treeWidget()
     if not tree:
         return False
     
     lbl = tree.itemWidget(self, column)
     if not html and lbl:
         lbl.deleteLater()
         return True
     
     elif not lbl:
         lbl = QtGui.QLabel(tree)
         lbl.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction)
         lbl.setOpenExternalLinks(True)
         tree.setItemWidget(self, column, lbl)
     
     lbl.setText(html)
     return True
Example #13
0
    def __init__(self, parent, record):
        super(XLogRecordItem, self).__init__(parent)

        # set default properties
        self.setFixedHeight(22)

        created = datetime.datetime.fromtimestamp(record.created)

        self.setData(0, QtCore.Qt.DisplayRole, wrapVariant(record.levelname))
        self.setData(1, QtCore.Qt.DisplayRole, wrapVariant(record.levelno))
        self.setData(2, QtCore.Qt.DisplayRole, wrapVariant(record.name))
        self.setData(3, QtCore.Qt.DisplayRole, wrapVariant(str(created)))
        self.setData(4, QtCore.Qt.DisplayRole, wrapVariant(record.message))
        self.setData(
            5, QtCore.Qt.DisplayRole,
            wrapVariant('% 10.4f' % (record.relativeCreated / 1000.0)))
        self.setData(6, QtCore.Qt.DisplayRole, wrapVariant(record.filename))
        self.setData(7, QtCore.Qt.DisplayRole, wrapVariant(record.module))
        self.setData(8, QtCore.Qt.DisplayRole, wrapVariant(record.funcName))
        self.setData(9, QtCore.Qt.DisplayRole, wrapVariant(record.lineno))
        self.setData(10, QtCore.Qt.DisplayRole, wrapVariant(record.pathname))
        self.setData(11, QtCore.Qt.DisplayRole, wrapVariant(record.process))
        self.setData(12, QtCore.Qt.DisplayRole,
                     wrapVariant(record.processName))
        self.setData(13, QtCore.Qt.DisplayRole, wrapVariant(record.thread))
        self.setData(14, QtCore.Qt.DisplayRole, wrapVariant(record.threadName))

        clr = XLogRecordItem.Colors.get(record.levelno)
        if clr:
            for i in range(self.columnCount()):
                self.setForeground(i, QtGui.QColor(clr))

        # create custom properties
        self._record = record
Example #14
0
    def setMovie(self, column, movie):
        """
        Sets the movie that will play for the given column.
        
        :param      column | <int>
                    movie  | <QtGui.QMovie> || None
        """
        curr = self._movies.get(column)
        if curr == movie:
            return True
        else:
            try:
                curr.frameChanged.disconnect(self._updateFrame)
            except StandardError:
                pass
        
        if movie is not None:
            self.requireCleanup()

            self._movies[column] = movie
            self.setIcon(column, QtGui.QIcon(movie.currentPixmap()))
            
            try:
                movie.frameChanged.connect(self._updateFrame,
                                           QtCore.Qt.UniqueConnection)
            except StandardError:
                pass
        else:
            self._movies.pop(column, None)
 def setGridPen(self, gridPen):
     """
     Sets the pen that will be used when drawing the grid lines.
     
     :param      gridPen | <QtGui.QPen> || <QtGui.QColor>
     """
     self._gridPen = QtGui.QPen(gridPen)
Example #16
0
 def _updateFrame(self):
     """
     Updates the frame for the given sender.
     """
     mov = self.movie()
     if mov:
         self.setIcon(QtGui.QIcon(mov.currentPixmap()))
Example #17
0
 def setExpandedIcon( self, column, icon ):
     """
     Sets the icon to be used when the item is expanded.
     
     :param      column | <int>
                 icon   | <QtGui.QIcon> || None
     """
     self._expandedIcon[column] = QtGui.QIcon(icon)
 def setCheckPartialMap(self, pixmap):
     """
     Sets the pixmap to be used when rendering a check state in the \
     partial state.
     
     :param      pixmap | <QtGui.QPixmap> || <str> || None
     """
     self._checkPartialMap = QtGui.QPixmap(pixmap)
Example #19
0
 def __init__(self, parent):
     super(XLogRecordView, self).__init__(parent)
     
     # define custom properties
     self._logger = XLogRecordWidget(self)
     layout = QtGui.QHBoxLayout()
     layout.setContentsMargins(0, 0, 0, 0)
     layout.addWidget(self._logger)
     self.setLayout(layout)
Example #20
0
 def setHoverIcon( self, column, icon ):
     """
     Returns the icon to use when coloring when the user hovers over
     the item for the given column.
     
     :param      column | <int>
                 icon   | <QtGui.QIcon)
     """
     self._hoverIcon[column] = QtGui.QIcon(icon)
Example #21
0
 def setHoverForeground( self, column, brush ):
     """
     Returns the brush to use when coloring when the user hovers over
     the item for the given column.
     
     :param      column | <int>
                 brush  | <QtGui.QBrush>
     """
     self._hoverForeground[column] = QtGui.QBrush(brush)
Example #22
0
 def setIconOverlay(self, column, icon):
     """
     Sets the icon overlay for this item at the inputed column to the
     given icon.
     
     :param      column | <int>
                 icon   | <str> || <QtGui.QIcon>
     """
     self._iconOverlays[column] = QtGui.QIcon(icon)
Example #23
0
    def setCentralWidget(self, widget):
        """
        Sets the central widget for this overlay to the inputed widget.

        :param      widget | <QtGui.QWidget>
        """
        self._centralWidget = widget

        if widget is not None:
            widget.setParent(self)

            widget.installEventFilter(self)

            # create the drop shadow effect
            effect = QtGui.QGraphicsDropShadowEffect(self)
            effect.setColor(QtGui.QColor('black'))
            effect.setBlurRadius(80)
            effect.setOffset(0, 0)
            widget.setGraphicsEffect(effect)
 def setForeground(self, column, brush):
     """
     Sets the default item foreground brush.
     
     :param      brush | <QtGui.QBrush> || None
     """
     if brush:
         self._foreground[column] = QtGui.QBrush(brush)
     elif column in self._background:
         self._foreground.pop(column)
Example #25
0
    def __init__(self, editor):
        super(XNumberArea, self).__init__(editor)

        self._codeEditor = editor

        # set default properties
        font = QtGui.QFont()
        font.setPointSize(8)
        font.setFamily('Courier New')
        self.setFont(font)
Example #26
0
    def updateUi(self):
        if self.logger() == 'root':
            log = logging.getLogger()
        else:
            log = logging.getLogger(self.logger())

        level = log.level
        if self.treeWidget().loggerWidget().hasLogger(self.logger()):
            checked = QtCore.Qt.Checked
            fg = QtGui.QColor('black')
        else:
            checked = QtCore.Qt.Unchecked
            fg = QtGui.QColor('gray')

        self.setCheckState(0, checked)
        self.setForeground(0, fg)
        self.setForeground(1, fg)

        text = XLoggerTreeWidget.LoggingMap.get(level, ('', ''))[0]
        self.setText(1, projex.text.pretty(text))
Example #27
0
    def __init__(self, parent=None):
        super(XSearchEdit, self).__init__(parent)

        # setup default properties
        self.setHint('enter search')
        self.setIcon(QtGui.QIcon(resources.find('img/search.png')))
        self.setCornerRadius(8)

        # setup custom properties
        self._cancelButton = XToolButton(self)
        self._cancelButton.setIcon(
            QtGui.QIcon(resources.find('img/remove_dark.png')))
        self._cancelButton.setToolTip('Clear Search Text')
        self._cancelButton.setShadowed(True)
        self._cancelButton.hide()
        self.addButton(self._cancelButton, QtCore.Qt.AlignRight)

        # create connections
        self._cancelButton.clicked.connect(self.clear)
        self.textChanged.connect(self.toggleCancelButton)
Example #28
0
    def __init__(self, parent):
        super(XScriptView, self).__init__(parent)

        # define custom properties
        self._edit = XCodeEdit(self)
        self._edit.setLanguage('Python')

        layout = QtGui.QHBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(self._edit)
        self.setLayout(layout)
Example #29
0
    def setPage(self, pageId, page):
        """
        Sets the page and id for the given page vs. auto-constructing it.  This will allow the
        developer to create a custom order for IDs.

        :param      pageId | <int>
                    page   | <projexui.widgets.xoverlaywizard.XOverlayWizardPage>
        """
        page.setParent(self)

        # create the drop shadow effect
        effect = QtGui.QGraphicsDropShadowEffect(page)
        effect.setColor(QtGui.QColor('black'))
        effect.setBlurRadius(50)
        effect.setOffset(0, 0)

        page.setGraphicsEffect(effect)

        self._pages[pageId] = page
        if self._startId == -1:
            self._startId = pageId
Example #30
0
 def __init__(self, parent):
     super(XConsoleView, self).__init__(parent)
     
     # define custom properties
     self._console = XConsoleEdit(self)
     
     layout = QtGui.QHBoxLayout()
     layout.setContentsMargins(0, 0, 0, 0)
     layout.addWidget(self._console)
     self.setLayout(layout)
     
     self.initialized.connect(self.setupConsole)