void tst_QTextScriptEngine::mirroredChars()
{
#if defined(Q_WS_MAC)
QSKIP("Not supported on Mac", SkipAll);
#endif
QFETCH(int, hintingPreference);
QFont font;
font.setHintingPreference(QFont::HintingPreference(hintingPreference));
QString s;
s.append(QLatin1Char('('));
s.append(QLatin1Char(')'));
HB_Glyph leftParenthesis;
HB_Glyph rightParenthesis;
{
QTextLayout layout(s);
layout.beginLayout();
layout.createLine();
layout.endLayout();
QTextEngine *e = layout.engine();
e->itemize();
e->shape(0);
QCOMPARE(e->layoutData->items[0].num_glyphs, ushort(2));
const QGlyphLayout &glyphLayout = e->layoutData->glyphLayout;
leftParenthesis = glyphLayout.glyphs[0];
rightParenthesis = glyphLayout.glyphs[1];
}
{
QTextLayout layout(s);
layout.setFlags(Qt::TextForceRightToLeft);
QTextEngine *e = layout.engine();
e->itemize();
e->shape(0);
QCOMPARE(e->layoutData->items[0].num_glyphs, ushort(2));
const QGlyphLayout &glyphLayout = e->layoutData->glyphLayout;
QCOMPARE(glyphLayout.glyphs[0], rightParenthesis);
QCOMPARE(glyphLayout.glyphs[1], leftParenthesis);
}
}
QFont fontId2font(int fontId)
{
static QFont* fonts[4]; // cached values
Q_ASSERT(fontId >= 0 && fontId < 4);
QFont* f = fonts[fontId];
if (f == 0) {
f = fonts[fontId] = new QFont();
f->setWeight(QFont::Normal); // if not set we get system default
f->setItalic(false);
#ifdef USE_GLYPHS
qreal size = 20.0;
#else
qreal size = 20.0 * MScore::DPI / PPI;
#endif
if (fontId == 0)
f->setFamily("MScore");
else if (fontId == 2) {
f->setFamily("FreeSerif");
size = 8.0; // * MScore::DPI / PPI;
#ifndef USE_GLYPHS
size = size * MScore::DPI / PPI;
#endif
}
else if (fontId == 3)
f->setFamily("Gonville-20");
else
qFatal("illegal font id %d", fontId);
f->setStyleStrategy(QFont::NoFontMerging);
// horizontal hinting is bad as note hooks do not attach to stems
// properly at some magnifications
f->setHintingPreference(QFont::PreferVerticalHinting);
#ifdef USE_GLYPHS
f->setPixelSize(lrint(size));
// f->setPointSizeF(size);
#else
f->setPixelSize(lrint(size));
#endif
}
return *f;
}
void tst_QPicture::serialization()
{
QDataStream stream;
const int thisVersion = stream.version();
for (int version = QDataStream::Qt_1_0; version <= thisVersion; ++version) {
const QDataStream::Version versionEnum = static_cast<QDataStream::Version>(version);
{
// streaming of null pictures
ensureSerializesCorrectly(QPicture(), versionEnum);
}
{
// picture with a simple line, checking bitwise equality
QPicture picture;
QPainter painter(&picture);
painter.drawLine(10, 20, 30, 40);
ensureSerializesCorrectly(picture, versionEnum);
}
}
{
// Test features that were added after Qt 4.5, as that was hard-coded as the major
// version for a while, which was incorrect. In this case, we'll test font hints.
QPicture picture;
QPainter painter;
QFont font;
font.setStyleName("Blah");
font.setHintingPreference(QFont::PreferFullHinting);
painter.begin(&picture);
painter.setFont(font);
painter.drawText(20, 20, "Hello");
painter.end();
Picture customPicture;
painter.begin(&customPicture);
picture.play(&painter);
const QFont actualFont = ((PaintEngine*)customPicture.paintEngine())->font();
painter.end();
QCOMPARE(actualFont.styleName(), QStringLiteral("Blah"));
QCOMPARE(actualFont.hintingPreference(), QFont::PreferFullHinting);
}
}
void tst_QRawFont::rawFontSetPixelSize()
{
QFETCH(QFont::HintingPreference, hintingPreference);
QTextLayout layout("Foobar");
QFont font = layout.font();
font.setHintingPreference(hintingPreference);
font.setPixelSize(12);
layout.setFont(font);
layout.beginLayout();
layout.createLine();
layout.endLayout();
QGlyphRun glyphs = layout.glyphRuns().at(0);
QRawFont rawFont = glyphs.rawFont();
QCOMPARE(rawFont.pixelSize(), 12.0);
rawFont.setPixelSize(24);
QCOMPARE(rawFont.pixelSize(), 24.0);
}
void TimeLineWidget::paintEvent( QPaintEvent * )
{
QPainter p( this );
// Draw background
p.fillRect( 0, 0, width(), height(), p.background() );
// Clip so that we only draw everything starting from the offset
p.setClipRect( m_xOffset, 0, width() - m_xOffset, height() );
// Draw the loop rectangle
int const & loopRectMargin = getLoopRectangleVerticalPadding();
int const loopRectHeight = this->height() - 2 * loopRectMargin;
int const loopStart = markerX( loopBegin() ) + 8;
int const loopEndR = markerX( loopEnd() ) + 9;
int const loopRectWidth = loopEndR - loopStart;
bool const loopPointsActive = loopPointsEnabled();
// Draw the main rectangle (inner fill only)
QRect outerRectangle( loopStart, loopRectMargin, loopRectWidth - 1, loopRectHeight - 1 );
p.fillRect( outerRectangle, loopPointsActive ? getActiveLoopBrush() : getInactiveLoopBrush());
// Draw the bar lines and numbers
// Activate hinting on the font
QFont font = p.font();
font.setHintingPreference( QFont::PreferFullHinting );
p.setFont(font);
int const fontAscent = p.fontMetrics().ascent();
int const fontHeight = p.fontMetrics().height();
QColor const & barLineColor = getBarLineColor();
QColor const & barNumberColor = getBarNumberColor();
tact_t barNumber = m_begin.getTact();
int const x = m_xOffset + s_posMarkerPixmap->width() / 2 -
( ( static_cast<int>( m_begin * m_ppt ) / MidiTime::ticksPerTact() ) % static_cast<int>( m_ppt ) );
for( int i = 0; x + i * m_ppt < width(); ++i )
{
++barNumber;
if( ( barNumber - 1 ) %
qMax( 1, qRound( 1.0f / 3.0f *
MidiTime::ticksPerTact() / m_ppt ) ) == 0 )
{
const int cx = x + qRound( i * m_ppt );
p.setPen( barLineColor );
p.drawLine( cx, 5, cx, height() - 6 );
const QString s = QString::number( barNumber );
p.setPen( barNumberColor );
p.drawText( cx + 5, ((height() - fontHeight) / 2) + fontAscent, s );
}
}
// Draw the main rectangle (outer border)
p.setPen( loopPointsActive ? getActiveLoopColor() : getInactiveLoopColor() );
p.setBrush( Qt::NoBrush );
p.drawRect( outerRectangle );
// Draw the inner border outline (no fill)
QRect innerRectangle = outerRectangle.adjusted( 1, 1, -1, -1 );
p.setPen( loopPointsActive ? getActiveLoopInnerColor() : getInactiveLoopInnerColor() );
p.setBrush( Qt::NoBrush );
p.drawRect( innerRectangle );
// Draw the position marker
p.setOpacity( 0.6 );
p.drawPixmap( m_posMarkerX, height() - s_posMarkerPixmap->height(), *s_posMarkerPixmap );
}
void BBTCOView::paintEvent( QPaintEvent * )
{
QPainter painter( this );
if( !needsUpdate() )
{
painter.drawPixmap( 0, 0, m_paintPixmap );
return;
}
setNeedsUpdate( false );
m_paintPixmap = m_paintPixmap.isNull() == true || m_paintPixmap.size() != size()
? QPixmap( size() ) : m_paintPixmap;
QPainter p( &m_paintPixmap );
QLinearGradient lingrad( 0, 0, 0, height() );
QColor c;
bool muted = m_bbTCO->getTrack()->isMuted() || m_bbTCO->isMuted();
// state: selected, muted, default, user selected
c = isSelected() ? selectedColor() : ( muted ? mutedBackgroundColor()
: ( m_bbTCO->m_useStyleColor ? painter.background().color()
: m_bbTCO->colorObj() ) );
lingrad.setColorAt( 0, c.light( 130 ) );
lingrad.setColorAt( 1, c.light( 70 ) );
if( gradient() )
{
p.fillRect( rect(), lingrad );
}
else
{
p.fillRect( rect(), c );
}
// bar lines
const int lineSize = 3;
p.setPen( c.darker( 200 ) );
tact_t t = Engine::getBBTrackContainer()->lengthOfBB( m_bbTCO->bbTrackIndex() );
if( m_bbTCO->length() > MidiTime::ticksPerTact() && t > 0 )
{
for( int x = static_cast<int>( t * pixelsPerTact() );
x < width() - 2;
x += static_cast<int>( t * pixelsPerTact() ) )
{
p.drawLine( x, TCO_BORDER_WIDTH, x, TCO_BORDER_WIDTH + lineSize );
p.drawLine( x, rect().bottom() - ( TCO_BORDER_WIDTH + lineSize ),
x, rect().bottom() - TCO_BORDER_WIDTH );
}
}
// pattern name
p.setRenderHint( QPainter::TextAntialiasing );
if( m_staticTextName.text() != m_bbTCO->name() )
{
m_staticTextName.setText( m_bbTCO->name() );
}
QFont font;
font.setHintingPreference( QFont::PreferFullHinting );
font.setPointSize( 8 );
p.setFont( font );
const int textTop = TCO_BORDER_WIDTH + 1;
const int textLeft = TCO_BORDER_WIDTH + 1;
p.setPen( textShadowColor() );
p.drawStaticText( textLeft + 1, textTop + 1, m_staticTextName );
p.setPen( textColor() );
p.drawStaticText( textLeft, textTop, m_staticTextName );
// inner border
p.setPen( c.lighter( 130 ) );
p.drawRect( 1, 1, rect().right() - TCO_BORDER_WIDTH,
rect().bottom() - TCO_BORDER_WIDTH );
// outer border
p.setPen( c.darker( 300 ) );
p.drawRect( 0, 0, rect().right(), rect().bottom() );
// draw the 'muted' pixmap only if the pattern was manualy muted
if( m_bbTCO->isMuted() )
{
const int spacing = TCO_BORDER_WIDTH;
const int size = 14;
p.drawPixmap( spacing, height() - ( size + spacing ),
embed::getIconPixmap( "muted", size, size ) );
}
p.end();
painter.drawPixmap( 0, 0, m_paintPixmap );
}
void tst_QFont::serialize_data()
{
QTest::addColumn<QFont>("font");
// The version in which the tested feature was added.
QTest::addColumn<QDataStream::Version>("minimumStreamVersion");
QFont basicFont;
// Versions <= Qt 2.1 had broken point size serialization,
// so we set an integer point size.
basicFont.setPointSize(9);
// Versions <= Qt 5.4 didn't serialize styleName, so clear it
basicFont.setStyleName(QString());
QFont font = basicFont;
QTest::newRow("defaultConstructed") << font << QDataStream::Qt_1_0;
font.setLetterSpacing(QFont::AbsoluteSpacing, 105);
QTest::newRow("letterSpacing") << font << QDataStream::Qt_4_5;
font = basicFont;
font.setWordSpacing(50.0);
QTest::newRow("wordSpacing") << font << QDataStream::Qt_4_5;
font = basicFont;
font.setPointSize(20);
QTest::newRow("pointSize") << font << QDataStream::Qt_1_0;
font = basicFont;
font.setPixelSize(32);
QTest::newRow("pixelSize") << font << QDataStream::Qt_3_0;
font = basicFont;
font.setStyleHint(QFont::Monospace);
QTest::newRow("styleHint") << font << QDataStream::Qt_1_0;
font = basicFont;
font.setStretch(4000);
QTest::newRow("stretch") << font << QDataStream::Qt_4_3;
font = basicFont;
font.setWeight(99);
QTest::newRow("weight") << font << QDataStream::Qt_1_0;
font = basicFont;
font.setUnderline(true);
QTest::newRow("underline") << font << QDataStream::Qt_1_0;
font = basicFont;
font.setStrikeOut(true);
QTest::newRow("strikeOut") << font << QDataStream::Qt_1_0;
font = basicFont;
font.setFixedPitch(true);
// This fails for versions less than this, as ignorePitch is set to false
// whenever setFixedPitch() is called, but ignorePitch is considered an
// extended bit, which were apparently not available until 4.4.
QTest::newRow("fixedPitch") << font << QDataStream::Qt_4_4;
font = basicFont;
font.setLetterSpacing(QFont::AbsoluteSpacing, 10);
// Fails for 4.4 because letterSpacing wasn't read until 4.5.
QTest::newRow("letterSpacing") << font << QDataStream::Qt_4_5;
font = basicFont;
font.setKerning(false);
QTest::newRow("kerning") << font << QDataStream::Qt_4_0;
font = basicFont;
font.setStyleStrategy(QFont::NoFontMerging);
// This wasn't read properly until 5.4.
QTest::newRow("styleStrategy") << font << QDataStream::Qt_5_4;
font = basicFont;
font.setHintingPreference(QFont::PreferFullHinting);
// This wasn't read until 5.4.
QTest::newRow("hintingPreference") << font << QDataStream::Qt_5_4;
font = basicFont;
font.setStyleName("Regular Black Condensed");
// This wasn't read until 5.4.
QTest::newRow("styleName") << font << QDataStream::Qt_5_4;
font = basicFont;
font.setCapitalization(QFont::AllUppercase);
// This wasn't read until 5.6.
QTest::newRow("capitalization") << font << QDataStream::Qt_5_6;
}
static QFont fontFromObject(QQmlV4Handle object, QV4::ExecutionEngine *v4, bool *ok)
{
if (ok)
*ok = false;
QFont retn;
QV4::Scope scope(v4);
QV4::ScopedObject obj(scope, object);
if (!obj) {
if (ok)
*ok = false;
return retn;
}
QV4::ScopedString s(scope);
QV4::ScopedValue vbold(scope, obj->get((s = v4->newString(QStringLiteral("bold")))));
QV4::ScopedValue vcap(scope, obj->get((s = v4->newString(QStringLiteral("capitalization")))));
QV4::ScopedValue vfam(scope, obj->get((s = v4->newString(QStringLiteral("family")))));
QV4::ScopedValue vstyle(scope, obj->get((s = v4->newString(QStringLiteral("styleName")))));
QV4::ScopedValue vital(scope, obj->get((s = v4->newString(QStringLiteral("italic")))));
QV4::ScopedValue vlspac(scope, obj->get((s = v4->newString(QStringLiteral("letterSpacing")))));
QV4::ScopedValue vpixsz(scope, obj->get((s = v4->newString(QStringLiteral("pixelSize")))));
QV4::ScopedValue vpntsz(scope, obj->get((s = v4->newString(QStringLiteral("pointSize")))));
QV4::ScopedValue vstrk(scope, obj->get((s = v4->newString(QStringLiteral("strikeout")))));
QV4::ScopedValue vundl(scope, obj->get((s = v4->newString(QStringLiteral("underline")))));
QV4::ScopedValue vweight(scope, obj->get((s = v4->newString(QStringLiteral("weight")))));
QV4::ScopedValue vwspac(scope, obj->get((s = v4->newString(QStringLiteral("wordSpacing")))));
QV4::ScopedValue vhint(scope, obj->get((s = v4->newString(QStringLiteral("hintingPreference")))));
QV4::ScopedValue vkerning(scope, obj->get((s = v4->newString(QStringLiteral("kerning")))));
QV4::ScopedValue vshaping(scope, obj->get((s = v4->newString(QStringLiteral("preferShaping")))));
// pull out the values, set ok to true if at least one valid field is given.
if (vbold->isBoolean()) {
retn.setBold(vbold->booleanValue());
if (ok) *ok = true;
}
if (vcap->isInt32()) {
retn.setCapitalization(static_cast<QFont::Capitalization>(vcap->integerValue()));
if (ok) *ok = true;
}
if (vfam->isString()) {
retn.setFamily(vfam->toQString());
if (ok) *ok = true;
}
if (vstyle->isString()) {
retn.setStyleName(vstyle->toQString());
if (ok) *ok = true;
}
if (vital->isBoolean()) {
retn.setItalic(vital->booleanValue());
if (ok) *ok = true;
}
if (vlspac->isNumber()) {
retn.setLetterSpacing(QFont::AbsoluteSpacing, vlspac->asDouble());
if (ok) *ok = true;
}
if (vpixsz->isInt32()) {
retn.setPixelSize(vpixsz->integerValue());
if (ok) *ok = true;
}
if (vpntsz->isNumber()) {
retn.setPointSize(vpntsz->asDouble());
if (ok) *ok = true;
}
if (vstrk->isBoolean()) {
retn.setStrikeOut(vstrk->booleanValue());
if (ok) *ok = true;
}
if (vundl->isBoolean()) {
retn.setUnderline(vundl->booleanValue());
if (ok) *ok = true;
}
if (vweight->isInt32()) {
retn.setWeight(static_cast<QFont::Weight>(vweight->integerValue()));
if (ok) *ok = true;
}
if (vwspac->isNumber()) {
retn.setWordSpacing(vwspac->asDouble());
if (ok) *ok = true;
}
if (vhint->isInt32()) {
retn.setHintingPreference(static_cast<QFont::HintingPreference>(vhint->integerValue()));
if (ok) *ok = true;
}
if (vkerning->isBoolean()) {
retn.setKerning(vkerning->booleanValue());
if (ok) *ok = true;
}
if (vshaping->isBoolean()) {
bool enable = vshaping->booleanValue();
if (enable)
retn.setStyleStrategy(static_cast<QFont::StyleStrategy>(retn.styleStrategy() & ~QFont::PreferNoShaping));
else
retn.setStyleStrategy(static_cast<QFont::StyleStrategy>(retn.styleStrategy() | QFont::PreferNoShaping));
}
return retn;
}
