void KTp::ContactViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyle *style = QApplication::style();
int textHeight = option.fontMetrics.height() * 2;
style->drawPrimitive(QStyle::PE_PanelItemViewItem, &option, painter);
QRect avatarRect = option.rect.adjusted(0, 0, 0, -textHeight);
QRect textRect = option.rect.adjusted(0, option.rect.height() - textHeight, 0, -3);
QPixmap avatar;
avatar.load(index.data(KTp::ContactAvatarPathRole).toString());
if (avatar.isNull()) {
avatar = QIcon::fromTheme(QStringLiteral("im-user-online")).pixmap(option.decorationSize);
} else if (avatar.width() > option.decorationSize.width() || avatar.height() > option.decorationSize.height()) {
//resize larger avatars if required
avatar = avatar.scaled(option.decorationSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
//draw leaving paddings on smaller (or non square) avatars
}
style->drawItemPixmap(painter, avatarRect, Qt::AlignCenter, avatar);
QTextOption textOption;
textOption.setAlignment(Qt::AlignCenter);
textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
painter->drawText(textRect, index.data().toString(), textOption);
}
//-----------------------------------------------------------------------------
// Function: RibbonGroup::paintEvent()
//-----------------------------------------------------------------------------
void RibbonGroup::paintEvent(QPaintEvent* /*event*/)
{
QPainter painter(this);
// Draw the base gradient.
QLinearGradient gradient(rect().topLeft(), rect().bottomLeft());
gradient.setColorAt(0.0, RibbonTheme::GRADIENTTOP);
gradient.setColorAt(0.1, Qt::white);
gradient.setColorAt(0.3, RibbonTheme::GRADIENTTOP);
gradient.setColorAt(1.0, RibbonTheme::GRADIENTBOTTOM);
painter.setRenderHints(QPainter::Antialiasing);
painter.fillRect(rect(), gradient);
// Draw a nice frame around the group area.
painter.setPen(QPen(RibbonTheme::GROUPTITLEGRADIENTTOP, 1));
painter.drawRect(rect());
// Draw the title background.
QRect titleRect = rect();
titleRect.setTop(rect().height() - TITLE_HEIGHT);
QLinearGradient titleGradient(titleRect.topLeft(), titleRect.bottomLeft());
titleGradient.setColorAt(0.0, RibbonTheme::GROUPTITLEGRADIENTTOP);
titleGradient.setColorAt(1.0, RibbonTheme::GROUPTITLEGRADIENTBOTTOM);
painter.fillRect(titleRect, titleGradient);
// Draw the title text.
QTextOption opt;
opt.setAlignment(Qt::AlignCenter);
painter.setPen(QPen(RibbonTheme::GROUPTITLETEXT));
painter.drawText(titleRect, title_, opt);
}
void
PlaylistDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
{
QStyleOptionViewItemV4 opt = option;
initStyleOption( &opt, QModelIndex() );
qApp->style()->drawControl( QStyle::CE_ItemViewItem, &opt, painter );
if ( option.state & QStyle::State_Selected )
{
opt.palette.setColor( QPalette::Text, opt.palette.color( QPalette::HighlightedText ) );
}
painter->save();
painter->setRenderHint( QPainter::Antialiasing );
painter->setPen( opt.palette.color( QPalette::Text ) );
QTextOption to;
to.setAlignment( Qt::AlignCenter );
QFont font = opt.font;
QFont boldFont = opt.font;
boldFont.setBold( true );
painter->drawPixmap( option.rect.adjusted( 10, 13, -option.rect.width() + 48, -13 ), m_playlistIcon );
painter->drawText( option.rect.adjusted( 56, 26, -100, -8 ), index.data( WelcomePlaylistModel::ArtistRole ).toString() );
QString trackCount = tr( "%1 tracks" ).arg( index.data( WelcomePlaylistModel::TrackCountRole ).toString() );
painter->drawText( option.rect.adjusted( option.rect.width() - 96, 2, 0, -2 ), trackCount, to );
painter->setFont( boldFont );
painter->drawText( option.rect.adjusted( 56, 6, -100, -option.rect.height() + 20 ), index.data().toString() );
painter->restore();
}
QwtRichTextDocument(const QString &text, int flags, const QFont &font)
{
setUndoRedoEnabled(false);
setDefaultFont(font);
#if QT_VERSION >= 0x040300
setHtml(text);
#else
setHtml(taggedRichText(text, flags));
#endif
// make sure we have a document layout
(void)documentLayout();
#if QT_VERSION >= 0x040300
QTextOption option = defaultTextOption();
if ( flags & Qt::TextWordWrap )
option.setWrapMode(QTextOption::WordWrap);
else
option.setWrapMode(QTextOption::NoWrap);
option.setAlignment((Qt::Alignment) flags);
setDefaultTextOption(option);
QTextFrame *root = rootFrame();
QTextFrameFormat fm = root->frameFormat();
fm.setBorder(0);
fm.setMargin(0);
fm.setPadding(0);
fm.setBottomMargin(0);
fm.setLeftMargin(0);
root->setFrameFormat(fm);
adjustSize();
#endif
}
//virtual
void PixButton::redoLabelTextLayout()
{
//TODO: somewhat wasteful. If there is no label, should just exit early and leave a layout that will be left unrendered by paint()
m_textLayoutObject.clearLayout();
m_textLayoutObject.setText(m_label);
m_textLayoutObject.setFont(m_textFont);
QTextOption textOpts;
textOpts.setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
textOpts.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
m_textLayoutObject.setTextOption(textOpts);
QFontMetrics textFontMetrics(m_textFont);
int leading = textFontMetrics.leading();
int rise = textFontMetrics.ascent();
qreal height = 0;
m_textLayoutObject.beginLayout();
while (height < m_labelMaxGeom.height()) {
QTextLine line = m_textLayoutObject.createLine();
if (!line.isValid())
break;
line.setLineWidth(m_labelMaxGeom.width());
if (m_textLayoutObject.lineCount() > 1)
{
height += leading;
}
line.setPosition(QPointF(0, height));
height += line.height();
}
height = qMin((quint32)DimensionsGlobal::roundUp(height),(quint32)m_labelMaxGeom.height());
height = DimensionsGlobal::roundDown(height) - (DimensionsGlobal::roundDown(height) % 2); //force to an even #
m_textLayoutObject.endLayout();
//TODO: PIXEL-ALIGN
m_labelGeom = DimensionsGlobal::realRectAroundRealPoint(QSizeF(m_textLayoutObject.boundingRect().width(),height)).toAlignedRect();
}
Intro::Intro(Force *f, QWidget *parent) :
QWidget(parent)
{
QFile file(":/texts/intro.txt");
QTextStream in(&file);
QString tmp;
QTextOption tops;
in.setCodec("UTF-8");
if(file.open(QFile::ReadOnly)) {
do {
tmp = in.readLine();
text.append(tmp + "<br />");
} while(!(tmp.isNull()));
}
st = QStaticText(text);
st.setTextFormat(Qt::RichText);
tops.setAlignment(Qt::AlignJustify);
tops.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
font.setBold(true);
font.setPixelSize(60);
connect(&timer, SIGNAL(timeout()), this, SLOT(update()));
timer.setInterval(66);
timer.start();
}
void QLabelPrivate::ensureTextLayouted() const
{
if (!textLayoutDirty)
return;
ensureTextPopulated();
Q_Q(const QLabel);
if (control) {
QTextDocument *doc = control->document();
QTextOption opt = doc->defaultTextOption();
opt.setAlignment(QFlag(this->align));
if (this->align & Qt::TextWordWrap)
opt.setWrapMode(QTextOption::WordWrap);
else
opt.setWrapMode(QTextOption::ManualWrap);
opt.setTextDirection(q->layoutDirection());
doc->setDefaultTextOption(opt);
QTextFrameFormat fmt = doc->rootFrame()->frameFormat();
fmt.setMargin(0);
doc->rootFrame()->setFrameFormat(fmt);
doc->setTextWidth(documentRect().width());
}
textLayoutDirty = false;
}
void DSlider::paintEvent(QPaintEvent *event)
{
Q_D(DSlider);
QPainter painter;
painter.begin(this);
// draw tips
QFont font = painter.font();
font.setPixelSize(12);
painter.setFont(font);
QPen pen = painter.pen();
pen.setColor(d->m_tipColor);
painter.setPen(pen);
QRect tmp = rect().adjusted(CustomDrawingLeftPadding - 5, 0, -CustomDrawingRightPadding + 5, 0);
QTextOption leftBottomOption;
leftBottomOption.setAlignment(Qt::AlignLeft | Qt::AlignBottom);
painter.drawText(tmp, d->m_leftTip, leftBottomOption);
QTextOption rightBottomOption;
rightBottomOption.setAlignment(Qt::AlignRight | Qt::AlignBottom);
painter.drawText(tmp, d->m_rightTip, rightBottomOption);
// draw scales
pen.setColor(d->m_scaleColor);
painter.setPen(pen);
foreach(int scale, d->m_scales) {
int x = d->getScalePosition(scale);
int y = height() - 8;
painter.drawLine(x, y, x, y - CustomDrawingScaleHeight);
}
if (d->m_handleHovering && !d->m_hoverTimout) {
QString str = QString::number(value());
int x = d->getScalePosition(value()) - painter.fontMetrics().width(str) / 2.0;
painter.setPen(d->m_hoverValueColor);
painter.drawText(x, 10, str);
}
painter.end();
QSlider::paintEvent(event);
}
void TemperatureView::paintEvent(QPaintEvent *event)
{
QPainter p(this);
const int leftOffset = 20;
const int topOffset = 20;
p.drawLine(leftOffset, topOffset, leftOffset, height() - topOffset);
p.drawLine(leftOffset, height() - topOffset, width() - leftOffset, height() - topOffset);
if (!mModel)
return;
int minTemp = 1000;
int maxTemp = -1000;
for (int column = 0; column < mModel->columnCount(); ++column) {
const QModelIndex index = mModel->index(mCurrentLocation, column);
const int temperature = index.data(WeatherModel::TemperatureRole).toInt();
minTemp = qMin(minTemp, temperature);
maxTemp = qMax(maxTemp, temperature);
}
const int tempStep = (height() - 2*topOffset)/((maxTemp - minTemp) == 0 ? 1 : (maxTemp - minTemp));
for (int i = 0; i <= (maxTemp-minTemp); i++) {
p.drawLine(leftOffset/2, topOffset + i*tempStep, leftOffset, topOffset + i*tempStep);
p.drawText(leftOffset/8, 13 + topOffset + i*tempStep, QString::number(maxTemp - i));
}
p.drawText(leftOffset/2, topOffset - 5, QString("°C"));
const int dayStep = (width() - 2*leftOffset)/5;
int previousX = 0;
int previousY = 0;
QTextOption option;
option.setAlignment(Qt::AlignCenter);
for (int column = 0; column < mModel->columnCount(); ++column) {
const QModelIndex index = mModel->index(mCurrentLocation, column);
const int temperature = index.data(WeatherModel::TemperatureRole).toInt();
const int x = (leftOffset + column*dayStep);
const int y = topOffset + (maxTemp - temperature)*tempStep;
p.drawText(QRectF(x, 0, dayStep, topOffset), index.data(WeatherModel::WeekdayRole).toString(), option);
if (column == 0)
p.drawLine(x, y, x + dayStep/2, y);
else
p.drawLine(previousX + dayStep/2, previousY, x + dayStep/2, y);
if (column == 4)
p.drawLine(x + dayStep/2, y, x + dayStep, y);
previousX = x;
previousY = y;
}
QWidget::paintEvent(event);
}
int TextOption::setAlignment ( lua_State * L ) //( Qt::Alignment alignment )void
{
QTextOption* lhs = ValueInstaller2<QTextOption>::check( L, 1 );
Enums enums(L);
Qt::Alignment alignment=(Qt::Alignment)enums.Alignment( 2 );
lhs->setAlignment( alignment );
return 0;
}
void TestDocumentLayout::placeAnchoredFrame()
{
initForNewTest(QString());
MockShape *picture = new MockShape();
picture->setSize(QSizeF(100, 100));
KTextAnchor *anchor = new KTextAnchor(picture);
anchor->setOffset(QPointF(23, 45));
QTextCursor cursor(doc);
KInlineTextObjectManager *manager = new KInlineTextObjectManager();
layout->setInlineTextObjectManager(manager);
MockLayoutState *state = new MockLayoutState(doc);
layout->setLayout(state);
state->shape = shape1;
QCOMPARE(doc->begin().text().length(), 0);
manager->insertInlineObject(cursor, anchor);
QCOMPARE(doc->begin().text().length(), 1);
QCOMPARE(cursor.position(), 1);
shape1->setPosition(QPointF(300, 300));
layout->layout();
QCOMPARE(picture->parent(), shape1);
QCOMPARE(picture->position(), QPointF(23, 59.4));
cursor.setPosition(0);
cursor.insertText("foo"); // moves my anchors slightly to the right/down and gives line height
layout->layout();
QCOMPARE(picture->parent(), shape1);
QPointF newPos = picture->position();
QVERIFY(newPos.x() > 23);
QVERIFY(newPos.y() > 45); // it adds the baseline now
cursor.movePosition(QTextCursor::End);
cursor.insertText("\nNew Line\nAnd another");
layout->layout();
QCOMPARE(picture->position(), newPos);
QTextLayout *firstLineLayout = doc->begin().layout();
QTextOption option = firstLineLayout->textOption();
option.setAlignment(Qt::AlignHCenter);
firstLineLayout->setTextOption(option);
layout->layout();
QTextLine first = doc->begin().layout()->lineAt(0);
QVERIFY(first.isValid());
QVERIFY(first.naturalTextRect().x() > 10);
newPos.setX(newPos.x() + first.naturalTextRect().x()); // text is moved due to alignment
QCOMPARE(picture->position(), newPos);
anchor->setOffset(QPointF());
anchor->setAlignment(KTextAnchor::Left);
anchor->setAlignment(KTextAnchor::TopOfParagraph);
layout->layout();
// image is 100 wide, now centered in a parent of 200 so X = 50
QCOMPARE(picture->position(), QPointF(50, 0));
}
static void update_alignment(void *_object)
{
THIS->no_change = TRUE;
QTextOption opt = WIDGET->document()->defaultTextOption();
opt.setAlignment((Qt::Alignment)CCONST_horizontal_alignment(THIS->align, ALIGN_NORMAL, true));
WIDGET->document()->setDefaultTextOption(opt);
THIS->no_change = FALSE;
}
QTextOption TextLabel::textOption() const
{
Qt::LayoutDirection direction = QApplication::layoutDirection();
Qt::Alignment alignment = QStyle::visualAlignment(direction, Qt::AlignLeft | Qt::AlignVCenter);
QTextOption option;
option.setTextDirection(direction);
option.setAlignment(alignment);
return option;
}
void setUpDisplayDoc(QTextDocument& displayDoc, const QFont font){
QTextOption to;
//to.setWrapMode(QTextOption::NoWrap);
to.setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
displayDoc.setDefaultTextOption(to);
displayDoc.setDefaultFont(font);
displayDoc.setDocumentMargin(0); //default is 4!
displayDoc.setIndentWidth(0);
displayDoc.setDefaultStyleSheet( UI_LIST_LINE_DEFAULT_STYLE);
}
void DanmakuMove::drawStandBy_(){
if (startPaintDMIndex_ <= dmCreater_->totalDMCount_) {
return;
}
if (!isNeedUpdateStandBy_)
return;
else
isNeedUpdateStandBy_ = false;
QFont font;
font.setBold(true);
font.setFamily(QString("Microsoft YaHei"));
font.setPixelSize(25);
QString styleStr = QString(
"<p>"
"<span style = \" font-size:%1px; color:#FF9DCB; \">%2< / span>"
"</p>");
QString standByStr = styleStr.arg(font.pixelSize()).arg(tr("Stand By"));
QTextDocument td;
td.setDefaultFont(font);
td.setDocumentMargin(10);
QTextOption op = td.defaultTextOption();
op.setAlignment(Qt::AlignHCenter);
td.setDefaultTextOption( op );
td.setHtml(standByStr);
td.setTextWidth(dmSideWidSize_.width());
QSize s = td.size().toSize();
if (standByPix_)
delete standByPix_;
standByPix_ = new QPixmap(QSize(dmSideWidSize_.width(), 60));
standByPix_->fill(Qt::transparent);
QPainter p(standByPix_);
p.setPen(QPen(QColor(0x49545A)));
p.setBrush(QBrush(QColor(0x49545A), Qt::SolidPattern));
p.setFont(font);
int border = 1;
QRect r(0, 0, standByPix_->width(), standByPix_->height());
p.setOpacity(0.6);
p.drawRoundedRect(r.adjusted(border, border, -border, -border), 3, 3);
td.drawContents(&p);
dmSideWidBKPixCache_->fill(Qt::transparent);
QPainter pSideDM(dmSideWidBKPixCache_);
pSideDM.drawPixmap(QPoint(0, dmSideWidBKPixCache_->height()-standByPix_->height()+border), *standByPix_);
}
void StyledLabel::setAlignment(Qt::Alignment alignment)
{
if (_alignment == alignment)
return;
_alignment = alignment;
QTextOption opt = _layout.textOption();
opt.setAlignment(alignment);
_layout.setTextOption(opt);
layout();
}
void ChatItem::initLayoutHelper(QTextLayout *layout, QTextOption::WrapMode wrapMode, Qt::Alignment alignment) const {
Q_ASSERT(layout);
layout->setText(data(MessageModel::DisplayRole).toString());
QTextOption option;
option.setWrapMode(wrapMode);
option.setAlignment(alignment);
layout->setTextOption(option);
QList<QTextLayout::FormatRange> formatRanges
= QtUi::style()->toTextLayoutList(formatList(), layout->text().length(), data(ChatLineModel::MsgLabelRole).toUInt());
layout->setAdditionalFormats(formatRanges);
}
void FormEditorItem::paintPlaceHolderForInvisbleItem(QPainter *painter) const
{
qreal stripesWidth = 12;
QRegion innerRegion = QRegion(m_boundingRect.adjusted(stripesWidth, stripesWidth, -stripesWidth, -stripesWidth).toRect());
QRegion outerRegion = QRegion(m_boundingRect.toRect()) - innerRegion;
painter->setClipRegion(outerRegion);
painter->setClipping(true);
painter->fillRect(m_boundingRect.adjusted(1, 1, -1, -1), Qt::BDiagPattern);
painter->setClipping(false);
QString displayText = qmlItemNode().id();
if (displayText.isEmpty())
displayText = qmlItemNode().simplifiedTypeName();
QTextOption textOption;
textOption.setAlignment(Qt::AlignTop);
textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
if (m_boundingRect.height() > 60) {
painter->save();
QFont font;
font.setStyleHint(QFont::SansSerif);
font.setBold(true);
font.setPixelSize(12);
painter->setFont(font);
QFontMetrics fm(font);
painter->rotate(90);
if (fm.width(displayText) > (m_boundingRect.height() - 32) && displayText.length() > 4) {
displayText = fm.elidedText(displayText, Qt::ElideRight, m_boundingRect.height() - 32, Qt::TextShowMnemonic);
}
QRectF rotatedBoundingBox;
rotatedBoundingBox.setWidth(m_boundingRect.height());
rotatedBoundingBox.setHeight(12);
rotatedBoundingBox.setY(-m_boundingRect.width() + 12);
rotatedBoundingBox.setX(20);
painter->setFont(font);
painter->setPen(QColor(48, 48, 96, 255));
painter->drawText(rotatedBoundingBox, displayText, textOption);
painter->restore();
}
}
StyledLabel::StyledLabel(QWidget *parent)
: QFrame(parent),
_wrapMode(QTextOption::NoWrap),
_alignment(Qt::AlignVCenter|Qt::AlignLeft),
_toolTipEnabled(true),
_resizeMode(NoResize)
{
setMouseTracking(true);
QTextOption opt = _layout.textOption();
opt.setWrapMode(_wrapMode);
opt.setAlignment(_alignment);
_layout.setTextOption(opt);
}
void TerrainView::paintEvent(QPaintEvent *e)
{
Q_D(TerrainView);
auto size = this->size();
SceneDefinition def;
def.cameraDir = QVector3D(std::cos(d->yaw_) * std::cos(d->pitch_),
std::sin(d->yaw_) * std::cos(d->pitch_),
std::sin(d->pitch_));
def.eye = d->centerPos_ - def.cameraDir;
def.viewWidth = size.width() / d->scale_;
def.viewHeight = size.height() / d->scale_;
auto img = d->render(size, def);
QPainter painter(this);
painter.drawImage(0, 0, img);
if (d->viewOptions.axises) {
QPointF axisPos(40, size.height() - 50);
QPointF axisX(d->rightVector.x(), d->upVector.x());
QPointF axisY(d->rightVector.y(), d->upVector.y());
QPointF axisZ(d->rightVector.z(), d->upVector.z());
float axisLen = 18.f;
auto drawText = [&](QString text, QPointF origin, QPointF dir) {
dir *= 1.f / std::sqrt(dir.x() * dir.x() + dir.y() * dir.y());
origin += dir * 12.f;
QRectF r(origin.x() - 100.f, origin.y() - 100.f, 200.f, 200.f);
QTextOption opt;
opt.setAlignment(Qt::AlignCenter);
painter.drawText(r, text, opt);
};
painter.setPen(qRgb(0, 0, 255));
painter.drawLine(axisPos, axisPos + axisZ * axisLen);
drawText("Z", axisPos + axisZ * axisLen, axisZ);
painter.setPen(qRgb(255, 0, 0));
painter.drawLine(axisPos, axisPos + axisX * axisLen);
drawText("X", axisPos + axisX * axisLen, axisX);
painter.setPen(qRgb(0, 255, 0));
painter.drawLine(axisPos, axisPos + axisY * axisLen);
drawText("Y", axisPos + axisY * axisLen, axisY);
}
emit clientPaint(e);
}
QPixmap QtPropertyBrowserUtils::fontValuePixmap(const QFont &font)
{
QFont f = font;
QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter p(&img);
p.setRenderHint(QPainter::TextAntialiasing, true);
p.setRenderHint(QPainter::Antialiasing, true);
f.setPointSize(13);
p.setFont(f);
QTextOption t;
t.setAlignment(Qt::AlignCenter);
p.drawText(QRect(0, 0, 16, 16), QString(QLatin1Char('A')), t);
return QPixmap::fromImage(img);
}
void FormEditorItem::paintPlaceHolderForInvisbleItem(QPainter *painter) const
{
qreal stripesWidth = 12;
QRegion innerRegion = QRegion(boundingRect().adjusted(stripesWidth, stripesWidth, -stripesWidth, -stripesWidth).toRect());
QRegion outerRegion = QRegion(boundingRect().toRect()) - innerRegion;
painter->setClipRegion(outerRegion);
painter->setClipping(true);
painter->fillRect(boundingRect().adjusted(1, 1, -1, -1), Qt::BDiagPattern);
painter->setClipping(false);
QString displayText = qmlItemNode().id();
if (displayText.isEmpty())
displayText = qmlItemNode().simplifiedTypeName();
QTextOption textOption;
textOption.setAlignment(Qt::AlignCenter);
textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
if (boundingRect().width() > 60) {
painter->save();
QFont font;
font.setStyleHint(QFont::SansSerif);
font.setBold(true);
font.setPixelSize(14);
painter->setFont(font);
QFontMetrics fm(font);
if (fm.width(displayText) > (boundingRect().width() - 22) && displayText.length() > 4) {
displayText = fm.elidedText(displayText, Qt::ElideRight, boundingRect().width() - 22, Qt::TextShowMnemonic);
}
painter->setPen(QColor(255, 255, 255, 128));
painter->setCompositionMode(QPainter::CompositionMode_Exclusion);
painter->drawText(boundingRect().adjusted(-2, -2, 0,0), displayText, textOption);
painter->setFont(font);
painter->setPen(QColor(0, 0, 0, 255));
painter->drawText(boundingRect(), displayText, textOption);
painter->restore();
}
}
void QDeclarativeTextEditPrivate::updateDefaultTextOption()
{
QTextOption opt = document->defaultTextOption();
int oldAlignment = opt.alignment();
opt.setAlignment((Qt::Alignment)(int)(hAlign | vAlign));
QTextOption::WrapMode oldWrapMode = opt.wrapMode();
if (wrap)
opt.setWrapMode(QTextOption::WordWrap);
else
opt.setWrapMode(QTextOption::NoWrap);
if (oldWrapMode == opt.wrapMode() && oldAlignment == opt.alignment())
return;
document->setDefaultTextOption(opt);
}
void TextItem::init()
{
setTextInteractionFlags(Qt::TextEditorInteraction);
setFlag(ItemIsSelectable, true);
setFlag(ItemIsFocusable, true);
QTextOption options;
options.setWrapMode(QTextOption::NoWrap);
options.setAlignment(Qt::AlignCenter);
document()->setDefaultTextOption(options);
connect(document(), &QTextDocument::contentsChanged, this, &TextItem::checkText);
QFont f = font();
f.setPixelSize(13);
setFont(f);
}
GraphicsTextItem::GraphicsTextItem(){
setFlag(QGraphicsItem::ItemIsMovable);
setFlag(QGraphicsItem::ItemIsSelectable);
setFlag(QGraphicsItem::ItemIsFocusable);
setAcceptDrops(true);
setAcceptHoverEvents(true);
QTextDocument *tdocument = document();
tdocument->setModified(true);
QTextOption option = tdocument->defaultTextOption();
option.setAlignment(Qt::AlignHCenter);
tdocument->setDefaultTextOption(option);
//setTextWidth(tdocument->idealWidth());
setTextWidth(400);
}
void Node::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option)
Q_UNUSED(widget)
// Set node colors in subclasses
painter->save();
painter->setBrush(mBackground);
painter->setPen(Qt::black);
painter->drawRoundedRect(boundingRect(), 15, 15);
QTextOption textOption;
textOption.setAlignment(Qt::AlignCenter);
painter->drawText(boundingRect(), mName, textOption);
painter->restore();
emit updateConnections();
}
void PrintOut::addBox(int percent, const QString &text, Style style, Qt::Alignment halign)
{
QTextOption options;
options.setAlignment(halign | Qt::AlignTop);
options.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
QFont f = f10;
if (style == Strong)
f.setBold(true);
else if (style == Emphasis)
f.setItalic(true);
int wd = hsize * percent / 100;
QRect r(cp.rect.x() + cp.rect.width(), 0, wd, vsize);
const int ht = static_cast<int>(p.boundingRect(r, text, options).height());
Box b(r, text, f, options);
cp.boxes.append(b);
cp.rect.setSize(QSize(cp.rect.width() + wd, qMax(cp.rect.height(), ht)));
}
void TextItem::initText()
{
QTextOption to;
to.setAlignment(m_alignment);
if (m_autoWidth!=MaxStringLength)
to.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
else to.setWrapMode(QTextOption::NoWrap);
m_text->setDocumentMargin(0);
m_text->setDefaultTextOption(to);
m_text->setDefaultFont(transformToSceneFont(font()));
if ((m_angle==Angle0)||(m_angle==Angle180)){
m_text->setTextWidth(rect().width()-fakeMarginSize()*2);
} else {
m_text->setTextWidth(rect().height()-fakeMarginSize()*2);
}
m_textSize=m_text->size();
}
void HelpWidget::paintEvent(QPaintEvent* e)
{
Q_UNUSED(e);
QRectF r = rect().adjusted(1, 1, -1, -1);
QPainter p(this);
p.setRenderHint(QPainter::Antialiasing);
p.setPen(QColor(187, 174, 105));
p.setBrush(QColor(242, 238, 184));
p.drawRoundedRect(r, 4, 4);
p.setPen(QColor(104, 74, 64));
p.setFont(mFont);
QTextOption options;
options.setWrapMode(QTextOption::WordWrap);
options.setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
p.drawText(rect().adjusted(5, 5, -5, -5), mText, options);
}
//virtual
void PageTab::redoLabelTextLayout()
{
//TODO: somewhat wasteful. If there is no label, should just exit early and leave a layout that will be left unrendered by paint()
m_textLayoutObject.clearLayout();;
//TODO: Need a real fix later instead of localizing the labels at runtime
QString m_tabLabelLocalized = fromStdUtf8(LOCALIZED(m_tabLabel.toStdString()));
m_textLayoutObject.setText(m_tabLabelLocalized);
// int fontSize = qBound(4,(int)((qreal)(m_labelMaxGeom.height())*0.5),24) -2;
// fontSize = fontSize - (fontSize % 2);
// m_textFont.setPixelSize(fontSize);
m_textLayoutObject.setFont(m_textFont);
QTextOption textOpts;
textOpts.setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
textOpts.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
m_textLayoutObject.setTextOption(textOpts);
QFontMetrics textFontMetrics(m_textFont);
int leading = textFontMetrics.leading();
int rise = textFontMetrics.ascent();
qreal height = 0;
m_textLayoutObject.beginLayout();
while (height < m_labelMaxGeom.height()) {
QTextLine line = m_textLayoutObject.createLine();
if (!line.isValid())
break;
line.setLineWidth(m_labelMaxGeom.width());
if (m_textLayoutObject.lineCount() > 1)
{
height += leading;
}
line.setPosition(QPointF(0, height));
height += line.height();
}
height = qMin((quint32)DimensionsGlobal::roundUp(height),(quint32)m_labelMaxGeom.height());
height = DimensionsGlobal::roundDown(height) - (DimensionsGlobal::roundDown(height) % 2); //force to an even #
m_textLayoutObject.endLayout();
//TODO: PIXEL-ALIGN
m_labelGeom = DimensionsGlobal::realRectAroundRealPoint(QSizeF(m_textLayoutObject.boundingRect().width(),height)).toAlignedRect();
}
