QCommonStylePrivate Class Reference

#include <qcommonstyle_p.h>

Inheritance diagram for QCommonStylePrivate:

Public Functions
bool	isViewItemCached (const QStyleOptionViewItemV4 &option) const
	QCommonStylePrivate ()
void	tabLayout (const QStyleOptionTabV3 *opt, const QWidget *widget, QRect *textRect, QRect *pixmapRect) const
void	viewItemDrawText (QPainter *p, const QStyleOptionViewItemV4 *option, const QRect &rect) const
void	viewItemLayout (const QStyleOptionViewItemV4 *opt, QRect *checkRect, QRect *pixmapRect, QRect *textRect, bool sizehint) const
	Set sizehint to false to layout the elements inside opt->rect. More...
QSize	viewItemSize (const QStyleOptionViewItemV4 *option, int role) const
	~QCommonStylePrivate ()
Public Functions inherited from QStylePrivate
	QStylePrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
QStyleOptionViewItemV4 *	cachedOption
QRect	checkRect
QRect	decorationRect
QRect	displayRect
QIcon	tabBarcloseButtonIcon
Public Variables inherited from QStylePrivate
int	layoutSpacingIndex
QStyle *	proxyStyle
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 66 of file qcommonstyle_p.h.

Constructors and Destructors

QCommonStylePrivate()

QCommonStylePrivate::QCommonStylePrivate ( )

inline

Definition at line 70 of file qcommonstyle_p.h.

    : cachedOption(0)
#endif
    { }

~QCommonStylePrivate()

QCommonStylePrivate::~QCommonStylePrivate ( )

inline

Definition at line 77 of file qcommonstyle_p.h.

    {
        delete cachedOption;
    }

Functions

isViewItemCached()

bool QCommonStylePrivate::isViewItemCached ( const QStyleOptionViewItemV4 &  option ) const

inline

Definition at line 88 of file qcommonstyle_p.h.

                                                                      {
        return cachedOption && (option.rect == cachedOption->rect
               && option.direction == cachedOption->direction
               && option.state == cachedOption->state
               && option.displayAlignment == cachedOption->displayAlignment
               && option.decorationAlignment == cachedOption->decorationAlignment
               && option.decorationPosition == cachedOption->decorationPosition
               && option.decorationSize == cachedOption->decorationSize
               && option.font == cachedOption->font
               && option.features == cachedOption->features
               && option.widget == cachedOption->widget
               && option.index == cachedOption->index
               && option.icon.isNull() == cachedOption->icon.isNull()
               && option.text == cachedOption->text
               && option.viewItemPosition == cachedOption->viewItemPosition);
    }

tabLayout()

void QCommonStylePrivate::tabLayout	(	const QStyleOptionTabV3 *	opt,
		const QWidget *	widget,
		QRect *	textRect,
		QRect *	iconRect
	)		const

Warning

This function is not part of the public interface. Compute the textRect and the pixmapRect from the opt rect

Uses the same computation than in QTabBar::tabSizeHint

Definition at line 1138 of file qcommonstyle.cpp.

{
    Q_ASSERT(textRect);
    Q_ASSERT(iconRect);
    QRect tr = opt->rect;
    bool verticalTabs = opt->shape == QTabBar::RoundedEast
                        || opt->shape == QTabBar::RoundedWest
                        || opt->shape == QTabBar::TriangularEast
                        || opt->shape == QTabBar::TriangularWest;
    if (verticalTabs)
        tr.setRect(0, 0, tr.height(), tr.width()); //0, 0 as we will have a translate transform

    int verticalShift = proxyStyle->pixelMetric(QStyle::PM_TabBarTabShiftVertical, opt, widget);
    int horizontalShift = proxyStyle->pixelMetric(QStyle::PM_TabBarTabShiftHorizontal, opt, widget);
    int hpadding = proxyStyle->pixelMetric(QStyle::PM_TabBarTabHSpace, opt, widget) / 2;
    int vpadding = proxyStyle->pixelMetric(QStyle::PM_TabBarTabVSpace, opt, widget) / 2;
    if (opt->shape == QTabBar::RoundedSouth || opt->shape == QTabBar::TriangularSouth)
        verticalShift = -verticalShift;
    tr.adjust(hpadding, verticalShift - vpadding, horizontalShift - hpadding, vpadding);
    bool selected = opt->state & QStyle::State_Selected;
    if (selected) {
        tr.setTop(tr.top() - verticalShift);
        tr.setRight(tr.right() - horizontalShift);
    }

    // left widget
    if (!opt->leftButtonSize.isEmpty()) {
        tr.setLeft(tr.left() + 4 +
            (verticalTabs ? opt->leftButtonSize.height() : opt->leftButtonSize.width()));
    }
    // right widget
    if (!opt->rightButtonSize.isEmpty()) {
        tr.setRight(tr.right() - 4 -
        (verticalTabs ? opt->rightButtonSize.height() : opt->rightButtonSize.width()));
    }

    // icon
    if (!opt->icon.isNull()) {
        QSize iconSize = opt->iconSize;
        if (!iconSize.isValid()) {
            int iconExtent = proxyStyle->pixelMetric(QStyle::PM_SmallIconSize);
            iconSize = QSize(iconExtent, iconExtent);
        }
        QSize tabIconSize = opt->icon.actualSize(iconSize,
                        (opt->state & QStyle::State_Enabled) ? QIcon::Normal : QIcon::Disabled,
                        (opt->state & QStyle::State_Selected) ? QIcon::On : QIcon::Off  );

        *iconRect = QRect(tr.left(), tr.center().y() - tabIconSize.height() / 2,
                    tabIconSize.width(), tabIconSize .height());
        if (!verticalTabs)
            *iconRect = proxyStyle->visualRect(opt->direction, opt->rect, *iconRect);
        tr.setLeft(tr.left() + tabIconSize.width() + 4);
    }

    if (!verticalTabs)
        tr = proxyStyle->visualRect(opt->direction, opt->rect, tr);

    *textRect = tr;
}

viewItemDrawText()

void QCommonStylePrivate::viewItemDrawText	(	QPainter *	p,
		const QStyleOptionViewItemV4 *	option,
		const QRect &	rect
	)		const

Definition at line 924 of file qcommonstyle.cpp.

Referenced by ~QCommonStylePrivate().

{
    const QWidget *widget = option->widget;
    const int textMargin = proxyStyle->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1;

    QRect textRect = rect.adjusted(textMargin, 0, -textMargin, 0); // remove width padding
    const bool wrapText = option->features & QStyleOptionViewItemV2::WrapText;
    QTextOption textOption;
    textOption.setWrapMode(wrapText ? QTextOption::WordWrap : QTextOption::ManualWrap);
    textOption.setTextDirection(option->direction);
    textOption.setAlignment(QStyle::visualAlignment(option->direction, option->displayAlignment));
    QTextLayout textLayout;
    textLayout.setTextOption(textOption);
    textLayout.setFont(option->font);
    textLayout.setText(option->text);

    viewItemTextLayout(textLayout, textRect.width());

    QString elidedText;
    qreal height = 0;
    qreal width = 0;
    int elidedIndex = -1;
    const int lineCount = textLayout.lineCount();
    for (int j = 0; j < lineCount; ++j) {
        const QTextLine line = textLayout.lineAt(j);
        if (j + 1 <= lineCount - 1) {
            const QTextLine nextLine = textLayout.lineAt(j + 1);
            if ((nextLine.y() + nextLine.height()) > textRect.height()) {
                int start = line.textStart();
                int length = line.textLength() + nextLine.textLength();
                const QStackTextEngine engine(textLayout.text().mid(start, length), option->font);
                elidedText = engine.elidedText(option->textElideMode, textRect.width());
                height += line.height();
                width = textRect.width();
                elidedIndex = j;
                break;
            }
        }
        if (line.naturalTextWidth() > textRect.width()) {
            int start = line.textStart();
            int length = line.textLength();
            const QStackTextEngine engine(textLayout.text().mid(start, length), option->font);
            elidedText = engine.elidedText(option->textElideMode, textRect.width());
            height += line.height();
            width = textRect.width();
            elidedIndex = j;
            break;
        }
        width = qMax<qreal>(width, line.width());
        height += line.height();
    }

    const QRect layoutRect = QStyle::alignedRect(option->direction, option->displayAlignment,
                                                 QSize(int(width), int(height)), textRect);
    const QPointF position = layoutRect.topLeft();
    for (int i = 0; i < lineCount; ++i) {
        const QTextLine line = textLayout.lineAt(i);
        if (i == elidedIndex) {
            qreal x = position.x() + line.x();
            qreal y = position.y() + line.y() + line.ascent();
            p->save();
            p->setFont(option->font);
            p->drawText(QPointF(x, y), elidedText);
            p->restore();
            break;
        }
        line.draw(p, position);
    }
}

viewItemLayout()

void QCommonStylePrivate::viewItemLayout	(	const QStyleOptionViewItemV4 *	opt,
		QRect *	checkRect,
		QRect *	pixmapRect,
		QRect *	textRect,
		bool	sizehint
	)		const

Set sizehint to false to layout the elements inside opt->rect.

Warning

This function is not part of the public interface. compute the position for the different component of an item (pixmap, text, checkbox)

Set sizehint to true to ignore opt->rect and return rectangles in infinite space

Code duplicated in QItemDelegate::doLayout

Definition at line 1005 of file qcommonstyle.cpp.

Referenced by ~QCommonStylePrivate().

{
    Q_ASSERT(checkRect && pixmapRect && textRect);
    *pixmapRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::DecorationRole));
    *textRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::DisplayRole));
    *checkRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::CheckStateRole));

    const QWidget *widget = opt->widget;
    const bool hasCheck = checkRect->isValid();
    const bool hasPixmap = pixmapRect->isValid();
    const bool hasText = textRect->isValid();
    const int textMargin = hasText ? proxyStyle->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;
    const int pixmapMargin = hasPixmap ? proxyStyle->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;
    const int checkMargin = hasCheck ? proxyStyle->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;
    int x = opt->rect.left();
    int y = opt->rect.top();
    int w, h;

    if (textRect->height() == 0 && (!hasPixmap || !sizehint)) {
        //if there is no text, we still want to have a decent height for the item sizeHint and the editor size
        textRect->setHeight(opt->fontMetrics.height());
    }

    QSize pm(0, 0);
    if (hasPixmap) {
        pm = pixmapRect->size();
        pm.rwidth() += 2 * pixmapMargin;
    }
    if (sizehint) {
        h = qMax(checkRect->height(), qMax(textRect->height(), pm.height()));
        if (opt->decorationPosition == QStyleOptionViewItem::Left
            || opt->decorationPosition == QStyleOptionViewItem::Right) {
            w = textRect->width() + pm.width();
        } else {
            w = qMax(textRect->width(), pm.width());
        }
    } else {
        w = opt->rect.width();
        h = opt->rect.height();
    }

    int cw = 0;
    QRect check;
    if (hasCheck) {
        cw = checkRect->width() + 2 * checkMargin;
        if (sizehint) w += cw;
        if (opt->direction == Qt::RightToLeft) {
            check.setRect(x + w - cw, y, cw, h);
        } else {
            check.setRect(x, y, cw, h);
        }
    }

    QRect display;
    QRect decoration;
    switch (opt->decorationPosition) {
    case QStyleOptionViewItem::Top: {
        if (hasPixmap)
            pm.setHeight(pm.height() + pixmapMargin); // add space
        h = sizehint ? textRect->height() : h - pm.height();

        if (opt->direction == Qt::RightToLeft) {
            decoration.setRect(x, y, w - cw, pm.height());
            display.setRect(x, y + pm.height(), w - cw, h);
        } else {
            decoration.setRect(x + cw, y, w - cw, pm.height());
            display.setRect(x + cw, y + pm.height(), w - cw, h);
        }
        break; }
    case QStyleOptionViewItem::Bottom: {
        if (hasText)
            textRect->setHeight(textRect->height() + textMargin); // add space
        h = sizehint ? textRect->height() + pm.height() : h;

        if (opt->direction == Qt::RightToLeft) {
            display.setRect(x, y, w - cw, textRect->height());
            decoration.setRect(x, y + textRect->height(), w - cw, h - textRect->height());
        } else {
            display.setRect(x + cw, y, w - cw, textRect->height());
            decoration.setRect(x + cw, y + textRect->height(), w - cw, h - textRect->height());
        }
        break; }
    case QStyleOptionViewItem::Left: {
        if (opt->direction == Qt::LeftToRight) {
            decoration.setRect(x + cw, y, pm.width(), h);
            display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h);
        } else {
            display.setRect(x, y, w - pm.width() - cw, h);
            decoration.setRect(display.right() + 1, y, pm.width(), h);
        }
        break; }
    case QStyleOptionViewItem::Right: {
        if (opt->direction == Qt::LeftToRight) {
            display.setRect(x + cw, y, w - pm.width() - cw, h);
            decoration.setRect(display.right() + 1, y, pm.width(), h);
        } else {
            decoration.setRect(x, y, pm.width(), h);
            display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h);
        }
        break; }
    default:
        qWarning("doLayout: decoration position is invalid");
        decoration = *pixmapRect;
        break;
    }

    if (!sizehint) { // we only need to do the internal layout if we are going to paint
        *checkRect = QStyle::alignedRect(opt->direction, Qt::AlignCenter,
                                         checkRect->size(), check);
        *pixmapRect = QStyle::alignedRect(opt->direction, opt->decorationAlignment,
                                          pixmapRect->size(), decoration);
        // the text takes up all available space, unless the decoration is not shown as selected
        if (opt->showDecorationSelected)
            *textRect = display;
        else
            *textRect = QStyle::alignedRect(opt->direction, opt->displayAlignment,
                                            textRect->size().boundedTo(display.size()), display);
    } else {
        *checkRect = check;
        *pixmapRect = decoration;
        *textRect = display;
    }
}

viewItemSize()

QSize QCommonStylePrivate::viewItemSize	(	const QStyleOptionViewItemV4 *	option,
		int	role
	)		const

Definition at line 841 of file qcommonstyle.cpp.

Referenced by ~QCommonStylePrivate().

{
    const QWidget *widget = option->widget;
    switch (role) {
    case Qt::CheckStateRole:
        if (option->features & QStyleOptionViewItemV2::HasCheckIndicator)
            return QSize(proxyStyle->pixelMetric(QStyle::PM_IndicatorWidth, option, widget),
                         proxyStyle->pixelMetric(QStyle::PM_IndicatorHeight, option, widget));
        break;
    case Qt::DisplayRole:
        if (option->features & QStyleOptionViewItemV2::HasDisplay) {
            QTextOption textOption;
            textOption.setWrapMode(QTextOption::WordWrap);
            QTextLayout textLayout;
            textLayout.setTextOption(textOption);
            textLayout.setFont(option->font);
            textLayout.setText(option->text);
            const bool wrapText = option->features & QStyleOptionViewItemV2::WrapText;
            const int textMargin = proxyStyle->pixelMetric(QStyle::PM_FocusFrameHMargin, option, widget) + 1;
            QRect bounds = option->rect;
            switch (option->decorationPosition) {
            case QStyleOptionViewItem::Left:
            case QStyleOptionViewItem::Right:
                bounds.setWidth(wrapText && bounds.isValid() ? bounds.width() - 2 * textMargin : QFIXED_MAX);
                break;
            case QStyleOptionViewItem::Top:
            case QStyleOptionViewItem::Bottom:
                if (wrapText)
                    bounds.setWidth(bounds.isValid() ? bounds.width() - 2 * textMargin : option->decorationSize.width());
                else
                    bounds.setWidth(QFIXED_MAX);
                break;
            default:
                break;
            }

            qreal height = 0, widthUsed = 0;
            textLayout.beginLayout();
            while (true) {
                QTextLine line = textLayout.createLine();
                if (!line.isValid())
                    break;
                line.setLineWidth(bounds.width());
                line.setPosition(QPointF(0, height));
                height += line.height();
                widthUsed = qMax(widthUsed, line.naturalTextWidth());
            }
            textLayout.endLayout();
            const QSize size(qCeil(widthUsed), qCeil(height));
            return QSize(size.width() + 2 * textMargin, size.height());
        }
        break;
    case Qt::DecorationRole:
        if (option->features & QStyleOptionViewItemV2::HasDecoration) {
            return option->decorationSize;
        }
        break;
    default:
        break;
    }

    return QSize(0, 0);
}

Properties

cachedOption

QStyleOptionViewItemV4* QCommonStylePrivate::cachedOption

mutable

Definition at line 87 of file qcommonstyle_p.h.

Referenced by ~QCommonStylePrivate().

checkRect

QRect QCommonStylePrivate::checkRect

mutable

Definition at line 86 of file qcommonstyle_p.h.

Referenced by ~QCommonStylePrivate().

decorationRect

QRect QCommonStylePrivate::decorationRect

mutable

Definition at line 86 of file qcommonstyle_p.h.

displayRect

QRect QCommonStylePrivate::displayRect

mutable

Definition at line 86 of file qcommonstyle_p.h.

tabBarcloseButtonIcon

QIcon QCommonStylePrivate::tabBarcloseButtonIcon

mutable

Definition at line 105 of file qcommonstyle_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/styles/qcommonstyle_p.h
• /src/gui/styles/qcommonstyle.cpp