int SvgView::renderText(const QStringRef &text)
{
scene->clear();
QRectF currentMarginsRect;
if (changeMargins)
currentMarginsRect = QRectF(QPointF(sheetRect.topRight().x() - marginsRect.topRight().x(),
marginsRect.topLeft().y()),
QPointF(sheetRect.bottomRight().x() - marginsRect.bottomLeft().x(),
marginsRect.bottomRight().y()));
else
currentMarginsRect = marginsRect;
scene->addRect(sheetRect);
scene->addRect(currentMarginsRect, QPen(Qt::darkGray));
QPointF cursor(currentMarginsRect.x(), currentMarginsRect.y());
int endOfSheet = 0;
for (QChar symbol : text)
{
qreal letterWidth = fontSize * dpmm / 4, letterHeight = fontSize * dpmm;
//don't try to go beyond the right margin
if (cursor.x() > (currentMarginsRect.x() + currentMarginsRect.width() - letterWidth))
{
if (symbol.isSpace()) //ignore whitespace-symbols at the end of the current line
continue;
cursor += QPointF(currentMarginsRect.x() - cursor.x(), letterHeight + lineSpacing * dpmm);
}
//stop rendering when you reach the end of sheet
if (cursor.y() > currentMarginsRect.bottomRight().y() - letterHeight)
return endOfSheet;
if (symbol.isSpace())
{
switch (symbol.toLatin1())
{
case '\t':
cursor += QPointF(letterWidth * spacesInTab, 0.0);
endOfSheet++;
continue;
case '\n':
cursor += QPointF(currentMarginsRect.x() - cursor.x(), letterHeight + lineSpacing * dpmm);
endOfSheet++;
continue;
default:
cursor += QPointF(letterWidth, 0.0);
endOfSheet++;
continue;
}
}
if (!font.contains(symbol))
{
cursor += QPointF(letterWidth, 0.0);
endOfSheet++;
continue;
}
QGraphicsSvgItem *letter = new QGraphicsSvgItem(font.values(symbol).at(qrand() % font.values(symbol).size()));
if (useCustomFontColor)
{
QGraphicsColorizeEffect *colorEffect = new QGraphicsColorizeEffect();
colorEffect->setColor(fontColor);
letter->setGraphicsEffect(colorEffect);
}
letter->setScale(letterHeight / letter->boundingRect().height());
letterWidth = letter->boundingRect().width() * letter->scale() + letterSpacing * dpmm;
letter->setPos(cursor);
cursor += QPointF(letterWidth, 0.0);
scene->addItem(letter);
endOfSheet++;
}
return endOfSheet;
}
/** Retrieve the named tile from the WMS server. A tileCompleted signal will
* be emitted when the tile is ready.
*/
void
WMSRequester::retrieveTile(const QString& tileName,
const QString& surface,
const QRectF& tileRect,
unsigned int tileSize,
vesta::TextureMap* texture)
{
if (!m_surfaces.contains(surface))
{
// Surface not defined
return;
}
QString fileName = tileFileName(tileName, surface);
QFileInfo fileInfo(fileName);
if (fileInfo.exists())
{
QImage image(fileName);
emit imageCompleted(tileName, image);
return;
}
LatLongBoundingBox tileBox(tileRect.x(),
tileRect.y(),
tileRect.x() + tileRect.width(),
tileRect.y() + tileRect.height());
SurfaceProperties surfaceProps = m_surfaces[surface];
unsigned int wmsTileWidth = surfaceProps.tileWidth;
unsigned int wmsTileHeight = surfaceProps.tileHeight;
LatLongBoundingBox topLeft = surfaceProps.topLeft;
double tileLongExtent = tileBox.east - tileBox.west;
double tileLatExtent = tileBox.north - tileBox.south;
double requestedResolution = tileLongExtent / double(tileSize);
double baseWmsResolution = (topLeft.east - topLeft.west) / double(wmsTileWidth);
unsigned int wmsLevel = 0;
while (requestedResolution < baseWmsResolution / (1 << wmsLevel))
{
wmsLevel++;
}
double wmsTileLongExtent = (topLeft.east - topLeft.west) / (1 << wmsLevel);
double wmsTileLatExtent = (topLeft.north - topLeft.south) / (1 << wmsLevel);
topLeft.east = topLeft.west + wmsTileLongExtent;
topLeft.south = topLeft.north - wmsTileLatExtent;
int westIndex = int(floor((tileBox.west - topLeft.west) / wmsTileLongExtent));
int southIndex = int(floor((tileBox.south - topLeft.south) / wmsTileLatExtent));
int eastIndex = int(ceil((tileBox.east - topLeft.west) / wmsTileLongExtent));
int northIndex = int(ceil((tileBox.north - topLeft.south) / wmsTileLatExtent));
TileAssembly* tileAssembly = new TileAssembly;
tileAssembly->tileImage;
tileAssembly->requestCount = 0;
tileAssembly->tileName = tileName;
tileAssembly->surfaceName = surface;
tileAssembly->tileWidth = tileSize;
tileAssembly->tileHeight = tileSize;
tileAssembly->texture = texture;
for (int lat = southIndex; lat < northIndex; ++lat)
{
for (int lon = westIndex; lon < eastIndex; ++lon)
{
LatLongBoundingBox bbox;
bbox.west = topLeft.west + lon * wmsTileLongExtent;
bbox.south = topLeft.south + lat * wmsTileLatExtent;
bbox.east = bbox.west + wmsTileLongExtent;
bbox.north = bbox.south + wmsTileLatExtent;
QString urlString = createWmsUrl(surfaceProps.requestUrl, bbox, surfaceProps.tileWidth, surfaceProps.tileHeight);
TileBuildOperation op;
op.tile = tileAssembly;
op.subrect = QRectF(float(tileSize * (bbox.west - tileBox.west) / tileLongExtent),
-float(tileSize * (bbox.north - tileBox.north) / tileLatExtent),
tileSize * wmsTileLongExtent / tileLongExtent, tileSize * wmsTileLatExtent / tileLatExtent);
op.urlString = urlString;
op.tile->requestCount++;
if (m_dispatchedRequestCount < MaxOutstandingNetworkRequests)
{
requestTile(op);
}
else
{
QMutexLocker locker(&m_mutex);
m_queuedTiles.append(op);
}
}
}
}
void DebugDialog::debug(QString prefix, const QRectF &rect, DebugLevel debug, QObject *ancestor) {
QString msg = prefix+QString(" rect: x=%1 y=%2 w=%3 h=%4")
.arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height());
DebugDialog::debug(msg,debug,ancestor);
}
QSGNode *QQuickImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
Q_D(QQuickImage);
QSGTexture *texture = d->sceneGraphRenderContext()->textureForFactory(d->pix.textureFactory(), window());
// Copy over the current texture state into the texture provider...
if (d->provider) {
d->provider->m_smooth = d->smooth;
d->provider->m_mipmap = d->mipmap;
d->provider->updateTexture(texture);
}
if (!texture || width() <= 0 || height() <= 0) {
delete oldNode;
return 0;
}
QSGImageNode *node = static_cast<QSGImageNode *>(oldNode);
if (!node) {
d->pixmapChanged = true;
node = d->sceneGraphContext()->createImageNode();
}
QRectF targetRect;
QRectF sourceRect;
QSGTexture::WrapMode hWrap = QSGTexture::ClampToEdge;
QSGTexture::WrapMode vWrap = QSGTexture::ClampToEdge;
qreal pixWidth = (d->fillMode == PreserveAspectFit) ? d->paintedWidth : d->pix.width() / d->devicePixelRatio;
qreal pixHeight = (d->fillMode == PreserveAspectFit) ? d->paintedHeight : d->pix.height() / d->devicePixelRatio;
int xOffset = 0;
if (d->hAlign == QQuickImage::AlignHCenter)
xOffset = qCeil((width() - pixWidth) / 2.);
else if (d->hAlign == QQuickImage::AlignRight)
xOffset = qCeil(width() - pixWidth);
int yOffset = 0;
if (d->vAlign == QQuickImage::AlignVCenter)
yOffset = qCeil((height() - pixHeight) / 2.);
else if (d->vAlign == QQuickImage::AlignBottom)
yOffset = qCeil(height() - pixHeight);
switch (d->fillMode) {
default:
case Stretch:
targetRect = QRectF(0, 0, width(), height());
sourceRect = d->pix.rect();
break;
case PreserveAspectFit:
targetRect = QRectF(xOffset, yOffset, d->paintedWidth, d->paintedHeight);
sourceRect = d->pix.rect();
break;
case PreserveAspectCrop: {
targetRect = QRect(0, 0, width(), height());
qreal wscale = width() / qreal(d->pix.width());
qreal hscale = height() / qreal(d->pix.height());
if (wscale > hscale) {
int src = (hscale / wscale) * qreal(d->pix.height());
int y = 0;
if (d->vAlign == QQuickImage::AlignVCenter)
y = qCeil((d->pix.height() - src) / 2.);
else if (d->vAlign == QQuickImage::AlignBottom)
y = qCeil(d->pix.height() - src);
sourceRect = QRectF(0, y, d->pix.width(), src);
} else {
int src = (wscale / hscale) * qreal(d->pix.width());
int x = 0;
if (d->hAlign == QQuickImage::AlignHCenter)
x = qCeil((d->pix.width() - src) / 2.);
else if (d->hAlign == QQuickImage::AlignRight)
x = qCeil(d->pix.width() - src);
sourceRect = QRectF(x, 0, src, d->pix.height());
}
}
break;
case Tile:
targetRect = QRectF(0, 0, width(), height());
sourceRect = QRectF(-xOffset, -yOffset, width(), height());
hWrap = QSGTexture::Repeat;
vWrap = QSGTexture::Repeat;
break;
case TileHorizontally:
targetRect = QRectF(0, 0, width(), height());
sourceRect = QRectF(-xOffset, 0, width(), d->pix.height());
hWrap = QSGTexture::Repeat;
break;
case TileVertically:
targetRect = QRectF(0, 0, width(), height());
sourceRect = QRectF(0, -yOffset, d->pix.width(), height());
vWrap = QSGTexture::Repeat;
break;
case Pad:
qreal w = qMin(qreal(d->pix.width()), width());
qreal h = qMin(qreal(d->pix.height()), height());
qreal x = (d->pix.width() > width()) ? -xOffset : 0;
qreal y = (d->pix.height() > height()) ? -yOffset : 0;
targetRect = QRectF(x + xOffset, y + yOffset, w, h);
sourceRect = QRectF(x, y, w, h);
break;
};
qreal nsWidth = (hWrap == QSGTexture::Repeat) ? d->pix.width() / d->devicePixelRatio : d->pix.width();
qreal nsHeight = (vWrap == QSGTexture::Repeat) ? d->pix.height() / d->devicePixelRatio : d->pix.height();
QRectF nsrect(sourceRect.x() / nsWidth,
sourceRect.y() / nsHeight,
sourceRect.width() / nsWidth,
sourceRect.height() / nsHeight);
if (targetRect.isEmpty()
|| !qIsFinite(targetRect.width()) || !qIsFinite(targetRect.height())
|| nsrect.isEmpty()
|| !qIsFinite(nsrect.width()) || !qIsFinite(nsrect.height())) {
delete node;
return 0;
}
if (d->pixmapChanged) {
// force update the texture in the node to trigger reconstruction of
// geometry and the likes when a atlas segment has changed.
if (texture->isAtlasTexture() && (hWrap == QSGTexture::Repeat || vWrap == QSGTexture::Repeat || d->mipmap))
node->setTexture(texture->removedFromAtlas());
else
node->setTexture(texture);
d->pixmapChanged = false;
}
node->setMipmapFiltering(d->mipmap ? QSGTexture::Linear : QSGTexture::None);
node->setHorizontalWrapMode(hWrap);
node->setVerticalWrapMode(vWrap);
node->setFiltering(d->smooth ? QSGTexture::Linear : QSGTexture::Nearest);
node->setTargetRect(targetRect);
node->setInnerTargetRect(targetRect);
node->setSubSourceRect(nsrect);
node->setMirror(d->mirror);
node->setAntialiasing(d->antialiasing);
node->update();
return node;
}
void ChooseGeneralBox::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) {
//============================================================
//||========================================================||
//|| 萩僉夲�揖米薦議冷繍 ||
//|| ______ ______ ______ ______ ______ ||
//|| | | | | | | | | | | ||
//|| | g1 | | g2 | | g3 | | g4 | | g5 | ||
//|| | | | | | | | | | | ||
//|| ！！！！！！ ！！！！！！ ！！！！！！ ！！！！！！ ！！！！！！ ||
//|| ______ ______ ______ ______ ||
//|| | | | | | | | | ||
//|| | g6 | | g7 | | g8 | | g9 | ||
//|| | | | | | | | | ||
//|| ！！！！！！ ！！！！！！ ！！！！！！ ！！！！！！ ||
//|| ---------------------------------------------- ||
//|| \/ ||
//|| ______ ______ ||
//|| | | | | ||
//|| | hg | | dg | ||
//|| | | | | ||
//|| ！！！！！！ ！！！！！！ ||
//|| __________ ||
//|| | 鳩協 | ||
//|| ！！！！！！！！！！ ||
//|| ========================= ||
//|| ||
//============================================================
//
//
//==================================================
//|| 岑失岑泳鉱心麼繍 ||
//||==============================================||
//|| ||
//|| __________________ ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| | | ||
//|| ！！！！！！！！！！！！！！！！！！ ||
//|| ||
//|| ================== ||
//|| || confirm || ||
//|| ================== ||
//|| ||
//==================================================
painter->save();
painter->setBrush(QBrush(G_COMMON_LAYOUT.m_chooseGeneralBoxBackgroundColor));
QRectF rect = boundingRect();
const int x = rect.x();
const int y = rect.y();
const int w = rect.width();
const int h = rect.height();
painter->drawRect(QRect(x, y, w, h));
painter->drawRect(QRect(x, y, w, top_dark_bar));
G_COMMON_LAYOUT.m_chooseGeneralBoxTitleFont.paintText(painter, QRect(x, y, w, top_dark_bar), Qt::AlignCenter, single_result ? tr("Please select one general") : tr("Please select the same nationality generals"));
painter->restore();
painter->setPen(G_COMMON_LAYOUT.m_chooseGeneralBoxBorderColor);
painter->drawRect(QRect(x + 1, y + 1, w - 2, h - 2));
if (single_result) return;
int split_line_y = top_blank_width + G_COMMON_LAYOUT.m_cardNormalHeight + card_bottom_to_split_line;
if (general_number > 5)
split_line_y += (card_to_center_line + G_COMMON_LAYOUT.m_cardNormalHeight);
QPixmap line = G_ROOM_SKIN.getPixmap(QSanRoomSkin::S_SKIN_KEY_CHOOSE_GENERAL_BOX_SPLIT_LINE);
const int line_length = boundingRect().width() - 2 * left_blank_width;
painter->drawPixmap(left_blank_width, split_line_y, line, (line.width() - line_length) / 2, y, line_length, line.height());
QPixmap seat = G_ROOM_SKIN.getPixmap(QSanRoomSkin::S_SKIN_KEY_CHOOSE_GENERAL_BOX_DEST_SEAT);
QRect seat1_rect(rect.center().x() - G_COMMON_LAYOUT.m_cardNormalWidth - card_to_center_line - 2, split_line_y + split_line_to_card_seat - 2, G_COMMON_LAYOUT.m_cardNormalWidth + 4, G_COMMON_LAYOUT.m_cardNormalHeight + 4);
painter->drawPixmap(seat1_rect, seat);
IQSanComponentSkin::QSanSimpleTextFont font = G_COMMON_LAYOUT.m_chooseGeneralBoxDestSeatFont;
font.paintText(painter, seat1_rect, Qt::AlignCenter, tr("head_general"));
QRect seat2_rect(rect.center().x() + card_to_center_line - 2, split_line_y + split_line_to_card_seat - 2, G_COMMON_LAYOUT.m_cardNormalWidth + 4, G_COMMON_LAYOUT.m_cardNormalHeight + 4);
painter->drawPixmap(seat2_rect, seat);
font.paintText(painter, seat2_rect, Qt::AlignCenter, tr("deputy_general"));
}
void WTextSourceViewerLine::mousePressEvent ( QMouseEvent * e )
{
QRectF lineRect;
QPoint pos=e->pos();
if (e->button() != Qt::LeftButton)
return;
pos.setY(pos.y()+translation_y);
int i;
QBitArray hidden_lines;
hidden_lines.resize(number_of_lines);
for (i=0;i<number_of_lines;i++) hidden_lines[i]=true;
int current_line=-1;
int block_end=-1;
int block_start=-1;
bool hide_current_line=true;
bool found=false;
for (QTextBlock textBlock=text_document_p->begin();
textBlock!=text_document_p->end();
textBlock=textBlock.next())
{
TextSourceInstrumentationData *instrumentationData=dynamic_cast<TextSourceInstrumentationData*> (textBlock.userData());
if (instrumentationData)
{
lineRect=text_document_p->documentLayout()->blockBoundingRect(textBlock);
QRectF hitRect(0,lineRect.y(),width(),lineRect.height());
hidden_lines[instrumentationData->current_line-1]=false;
if (hitRect.contains(pos))
{
current_line = instrumentationData->current_line;
hide_current_line = (instrumentationData->instrumentations.isEmpty()) ;
if (hide_current_line)
found=true;
}
if (instrumentationData->instrumentations.isEmpty())
{
block_end=instrumentationData->current_line;
if (block_start==-1)
block_start=instrumentationData->current_line;
}
else
{
if (!hide_current_line)
found=false;
if (found)
{
found=false;
for (i=block_start-1;i<=block_end-1;i++)
hidden_lines[i]=hide_current_line;
}
block_end=-1;
block_start=-1;
}
}
}
if (found)
{
found=false;
for (i=block_start-1;i<=block_end-1;i++)
hidden_lines[i]=hide_current_line;
}
if (current_line<0)
{
e->accept();
return;
}
int scroll_to_line=current_line;
if (!hide_current_line)
{
int i;
for (i=current_line;i<number_of_lines && hidden_lines[i];i++)
hidden_lines[i]=false;
for (i=current_line-2;i>=0 && hidden_lines[i];i--)
hidden_lines[i]=false;
}
else
{
for (int i=current_line;i<number_of_lines && hidden_lines[i];i++)
scroll_to_line=i+2;
}
emit hideLines(scroll_to_line,hidden_lines);
e->accept();
}
void SdfRenderer::render(QPainter *painter, const QRectF &bounds)
{
current_size_x = static_cast<int>(bounds.width());
current_size_y = static_cast<int>(bounds.height());
mStartX = static_cast<int>(bounds.x());
mStartY = static_cast<int>(bounds.y());
this->painter = painter;
QDomElement docElem = doc.documentElement();
QDomNode node = docElem.firstChild();
while(!node.isNull())
{
QDomElement elem = node.toElement();
if(!elem.isNull())
{
if (elem.tagName()=="line")
{
line(elem);
}
else if(elem.tagName()=="ellipse")
{
ellipse(elem);
}
else if (elem.tagName() == "arc") {
arc(elem);
}
else if(elem.tagName()=="background")
{
background(elem);
}
else if(elem.tagName()=="text")
{
draw_text(elem);
}
else if (elem.tagName()=="rectangle")
{
rectangle(elem);
}
else if (elem.tagName()=="polygon")
{
polygon(elem);
}
else if (elem.tagName()=="point")
{
point(elem);
}
else if(elem.tagName()=="path")
{
path_draw(elem);
}
else if(elem.tagName()=="stylus")
{
stylus_draw(elem);
}
else if(elem.tagName()=="curve")
{
curve_draw(elem);
}
else if(elem.tagName()=="image")
{
image_draw(elem);
}
}
node = node.nextSibling();
}
this->painter = 0;
}
/*! Paints the gantt item \a idx using \a painter and \a opt
*/
void ItemDelegate::paintGanttItem( QPainter* painter,
const StyleOptionGanttItem& opt,
const QModelIndex& idx )
{
if ( !idx.isValid() ) return;
const ItemType typ = static_cast<ItemType>( idx.model()->data( idx, ItemTypeRole ).toInt() );
const QString& txt = opt.text;
QRectF itemRect = opt.itemRect;
QRectF boundingRect = opt.boundingRect;
boundingRect.setY( itemRect.y() );
boundingRect.setHeight( itemRect.height() );
//qDebug() << "itemRect="<<itemRect<<", boundingRect="<<boundingRect;
painter->save();
QPen pen = defaultPen( typ );
if ( opt.state & QStyle::State_Selected ) pen.setWidth( 2*pen.width() );
painter->setPen( pen );
painter->setBrush( defaultBrush( typ ) );
qreal pw = painter->pen().width()/2.;
switch( typ ) {
case TypeTask:
if ( itemRect.isValid() ) {
// TODO
qreal pw = painter->pen().width()/2.;
pw-=1;
QRectF r = itemRect;
r.translate( 0., r.height()/6. );
r.setHeight( 2.*r.height()/3. );
painter->setBrushOrigin( itemRect.topLeft() );
painter->save();
painter->translate( 0.5, 0.5 );
painter->drawRect( r );
bool ok;
qreal completion = idx.model()->data( idx, KDGantt::TaskCompletionRole ).toDouble( &ok );
if ( ok ) {
qreal h = r.height();
QRectF cr( r.x(), r.y()+h/4. + 1,
r.width()*completion/100., h/2. - 2 );
painter->fillRect( cr, painter->pen().brush() );
}
painter->restore();
Qt::Alignment ta;
switch( opt.displayPosition ) {
case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break;
case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break;
case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break;
}
painter->drawText( boundingRect, ta, txt );
}
break;
case TypeSummary:
if ( opt.itemRect.isValid() ) {
// TODO
pw-=1;
const QRectF r = QRectF( opt.itemRect ).adjusted( -pw, -pw, pw, pw );
QPainterPath path;
const qreal deltaY = r.height()/2.;
const qreal deltaX = qMin( r.width()/qreal(2), deltaY );
path.moveTo( r.topLeft() );
path.lineTo( r.topRight() );
path.lineTo( QPointF( r.right(), r.top() + 2.*deltaY ) );
//path.lineTo( QPointF( r.right()-3./2.*delta, r.top() + delta ) );
path.quadTo( QPointF( r.right()-.5*deltaX, r.top() + deltaY ), QPointF( r.right()-2.*deltaX, r.top() + deltaY ) );
//path.lineTo( QPointF( r.left()+3./2.*delta, r.top() + delta ) );
path.lineTo( QPointF( r.left() + 2.*deltaX, r.top() + deltaY ) );
path.quadTo( QPointF( r.left()+.5*deltaX, r.top() + deltaY ), QPointF( r.left(), r.top() + 2.*deltaY ) );
path.closeSubpath();
painter->setBrushOrigin( itemRect.topLeft() );
painter->save();
painter->translate( 0.5, 0.5 );
painter->drawPath( path );
painter->restore();
Qt::Alignment ta;
switch( opt.displayPosition ) {
case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break;
case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break;
case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break;
}
painter->drawText( boundingRect, ta | Qt::AlignVCenter, txt );
}
break;
case TypeEvent: /* TODO */
//qDebug() << opt.boundingRect << opt.itemRect;
if ( opt.boundingRect.isValid() ) {
const qreal pw = painter->pen().width() / 2. - 1;
const QRectF r = QRectF( opt.rect ).adjusted( -pw, -pw, pw, pw );
QPainterPath path;
const qreal delta = static_cast< int >( r.height() / 2 );
path.moveTo( delta, 0. );
path.lineTo( 2.*delta, delta );
path.lineTo( delta, 2.*delta );
path.lineTo( 0., delta );
path.closeSubpath();
painter->save();
painter->translate( r.topLeft() );
painter->translate( 0.5, 0.5 );
painter->drawPath( path );
painter->restore();
Qt::Alignment ta;
switch( opt.displayPosition ) {
case StyleOptionGanttItem::Left: ta = Qt::AlignLeft; break;
case StyleOptionGanttItem::Right: ta = Qt::AlignRight; break;
case StyleOptionGanttItem::Center: ta = Qt::AlignCenter; break;
}
painter->drawText( boundingRect, ta | Qt::AlignVCenter, txt );
}
break;
default:
break;
}
painter->restore();
}
QPointF QuickGridDefinition::cellPoint(QRectF rect, int row, int column)
{
return QPointF(columnOffset(column) * rect.width() + rect.x(), rowOffset(row) * rect.height() + rect.y());
}
void EventsSceneArrowTmpItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
QRectF rect = boundingRect();
//painter->fillRect(rect, QColor(255, 0, 0, 30));
painter->setRenderHint(QPainter::Antialiasing);
int penWidth = 2;
QColor color = Qt::black;
switch(mState)
{
case eNormal:
color = Qt::black;
break;
case eAllowed:
color = QColor(77, 180, 62);
break;
case eForbidden:
color = Qt::red;
break;
default:
break;
}
painter->setPen(QPen(color, penWidth, Qt::DashLine));
painter->drawLine(mXFrom, mYFrom, mXTo, mYTo);
// arrows
float angle_rad = atanf(rect.width() / rect.height());
float angle_deg = angle_rad * 180. / M_PI;
QPainterPath path;
int arrow_w = 10;
int arrow_l = 15;
path.moveTo(-arrow_w/2, arrow_l/2);
path.lineTo(arrow_w/2, arrow_l/2);
path.lineTo(0, -arrow_l/2);
path.closeSubpath();
float posX = rect.width()/2;
float posY = rect.height()/2;
if(mXFrom < mXTo && mYFrom > mYTo)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else if(mXFrom < mXTo && mYFrom < mYTo)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(180 - angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else if(mXFrom > mXTo && mYFrom < mYTo)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(180 + angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else if(mXFrom > mXTo && mYFrom > mYTo)
{
painter->save();
painter->translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
painter->rotate(-angle_deg);
painter->fillPath(path, color);
painter->restore();
}
// Message
switch(mState)
{
case eAllowed:
case eForbidden:
{
float w = 40;
float h = 40;
QRectF r(rect.x() + (rect.width() - w)/2, rect.y() + (rect.height() - h)/2, w, h);
painter->setBrush(Qt::white);
painter->drawEllipse(r);
if(mState == eAllowed)
{
painter->drawText(r, Qt::AlignCenter, "OK");
}
else
{
painter->setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap));
painter->drawLine(r.x() + r.width()/4, r.y() + r.height()/4, r.x() + 3*r.width()/4, r.y() + 3*r.height()/4);
painter->drawLine(r.x() + r.width()/4, r.y() + 3*r.height()/4, r.x() + 3*r.width()/4, r.y() + r.height()/4);
}
}
default:
break;
}
}
void QZint::render(QPainter & painter, const QRectF & paintRect, AspectRatioMode mode)
{
encode();
bool textdone;
int comp_offset = 0, xoffset = m_whitespace, j, main_width = 0, addon_text_height = 0;
int yoffset = 0;
QString caption = QString::fromUtf8((const char *)m_zintSymbol->text, -1);
QFont fontSmall(fontstyle);
fontSmall.setPixelSize(fontPixelSizeSmall);
QFont fontLarge(fontstyle);
fontLarge.setPixelSize(fontPixelSizeLarge);
if (m_lastError.length())
{
painter.setFont(fontLarge);
painter.drawText(paintRect,Qt::AlignCenter,m_lastError);
return;
}
painter.save();
painter.setClipRect(paintRect,Qt::IntersectClip);
qreal xtr=paintRect.x();
qreal ytr=paintRect.y();
int zrow_height=m_zintSymbol->height;
int zrows=0;
for (int i=0;i<m_zintSymbol->rows;i++)
{
zrow_height-=m_zintSymbol->row_height[i];
if (!m_zintSymbol->row_height[i])
zrows++;
}
if (zrows)
{
zrow_height/=zrows;
for (int i=0;i<m_zintSymbol->rows;i++)
if (!m_zintSymbol->row_height[i])
m_zintSymbol->row_height[i]=zrow_height;
}
else
m_zintSymbol->height-=zrow_height;
qreal gwidth=m_zintSymbol->width;
qreal gheight=m_zintSymbol->height;
if (m_zintSymbol->symbology == BARCODE_MAXICODE)
{
gheight*=(maxi_width);
gwidth*=(maxi_width+1);
}
qreal xsf=1;
qreal ysf=1;
qreal textoffset = 0;
gwidth+=((m_border==BOX)?m_borderWidth*2:0);
gheight+=((m_border!=NO_BORDER)?m_borderWidth*2:0);
if(QString((const char*)m_zintSymbol->text).isEmpty() == false) {
textoffset = 9;
gheight += textoffset;
} else {
textoffset = 0;
}
gwidth+=m_zintSymbol->whitespace_width*2;
switch(mode)
{
case IgnoreAspectRatio:
xsf=(qreal)paintRect.width()/gwidth;
ysf=(qreal)paintRect.height()/gheight;
break;
case KeepAspectRatio:
if (paintRect.width()/gwidth<paintRect.height()/gheight)
{
ysf=xsf=(qreal)paintRect.width()/gwidth;
ytr+=(qreal)(paintRect.height()-gheight*ysf)/2;
}
else
{
ysf=xsf=(qreal)paintRect.height()/gheight;
xtr+=(qreal)(paintRect.width()-gwidth*xsf)/2;
}
break;
case CenterBarCode:
xtr+=((qreal)paintRect.width()-gwidth*xsf)/2;
ytr+=((qreal)paintRect.height()-gheight*ysf)/2;
break;
}
painter.setBackground(QBrush(m_bgColor));
painter.fillRect(paintRect,QBrush(m_bgColor));
painter.translate(xtr,ytr);
painter.scale(xsf,ysf);
QPen p;
p.setColor(m_fgColor);
p.setWidth(m_borderWidth);
painter.setPen(p);
QPainterPath pt;
if(m_zintSymbol->symbology != BARCODE_MAXICODE) {
/* Draw boundary bars or boxes around the symbol */
switch(m_border)
{
case BOX:
painter.fillRect(0,m_borderWidth,m_borderWidth,m_zintSymbol->height,QBrush(m_fgColor));
painter.fillRect(m_zintSymbol->width + xoffset + xoffset + m_borderWidth,m_borderWidth,m_borderWidth,m_zintSymbol->height,QBrush(m_fgColor));
painter.fillRect(0,0,m_zintSymbol->width + xoffset + xoffset + m_borderWidth + m_borderWidth,m_borderWidth,QBrush(m_fgColor));
painter.fillRect(0,m_zintSymbol->height + m_borderWidth,m_zintSymbol->width + xoffset + xoffset + m_borderWidth + m_borderWidth, m_borderWidth,QBrush(m_fgColor));
painter.translate(m_borderWidth+m_zintSymbol->whitespace_width,m_borderWidth);
yoffset = m_borderWidth;
break;
case BIND:
painter.fillRect(0,0,m_zintSymbol->width + xoffset + xoffset,m_borderWidth,QBrush(m_fgColor));
painter.fillRect(0,m_zintSymbol->height + m_borderWidth,m_zintSymbol->width + xoffset + xoffset, m_borderWidth,QBrush(m_fgColor));
painter.translate(m_zintSymbol->whitespace_width,m_borderWidth);
yoffset = m_borderWidth;
break;
default:
painter.translate(m_zintSymbol->whitespace_width,0);
break;;
}
}
while(!(module_set(m_zintSymbol->rows - 1, comp_offset))) {
comp_offset++;
}
xoffset = comp_offset;
/* Set up some values for displaying EAN and UPC symbols correctly */
main_width = m_zintSymbol->width;
if ((((m_zintSymbol->symbology == BARCODE_EANX) && (m_zintSymbol->rows == 1)) || (m_zintSymbol->symbology == BARCODE_EANX_CC))
|| (m_zintSymbol->symbology == BARCODE_ISBNX)) {
switch(caption.size()) {
case 13: /* EAN 13 */
case 16:
case 19:
if(m_zintSymbol->whitespace_width == 0) {
m_zintSymbol->whitespace_width = 10;
}
main_width = 96 + comp_offset;
break;
default:
main_width = 68 + comp_offset;
break;
}
}
if (((m_zintSymbol->symbology == BARCODE_UPCA) && (m_zintSymbol->rows == 1)) || (m_zintSymbol->symbology == BARCODE_UPCA_CC)) {
if(m_zintSymbol->whitespace_width == 0) {
m_zintSymbol->whitespace_width = 10;
}
main_width = 96 + comp_offset;
}
if (((m_zintSymbol->symbology == BARCODE_UPCE) && (m_zintSymbol->rows == 1)) || (m_zintSymbol->symbology == BARCODE_UPCE_CC)) {
if(m_zintSymbol->whitespace_width == 0) {
m_zintSymbol->whitespace_width = 10;
}
main_width = 51 + comp_offset;
}
p.setWidth(1);
painter.setPen(p);
if (m_zintSymbol->symbology == BARCODE_MAXICODE)
{
/* Draw Maxicode with hexagons */
painter.save();
painter.setRenderHint(QPainter::Antialiasing);
for (int r=0;r<m_zintSymbol->rows;r++)
{
for (int c=0;c<m_zintSymbol->width;c++)
{
if (module_set(r, c))
{
qreal col=(qreal)c*(maxi_width+1)+(r%2)*((maxi_width+1)/2);
qreal row=(qreal)r*(maxi_width+1)*0.868;
QPainterPath pt;
pt.moveTo(col+maxi_width/2, row);
pt.lineTo(col+maxi_width, row+maxi_diagonal/4);
pt.lineTo(col+maxi_width, row+(maxi_diagonal-maxi_diagonal/4));
pt.lineTo(col+maxi_width/2, row+maxi_diagonal);
pt.lineTo(col, row+(maxi_diagonal-maxi_diagonal/4));
pt.lineTo(col, row+maxi_diagonal/4);
pt.lineTo(col+maxi_width/2, row);
painter.fillPath(pt,QBrush(m_fgColor));
}
}
}
p.setWidth(maxi_width);
painter.setPen(p);
const qreal w=maxi_width+1;
painter.drawEllipse(QPointF(14.5*w,16.5*w*0.868),w,w);
painter.drawEllipse(QPointF(14.5*w,16.5*w*0.868),w+w*1.5,w+w*1.5);
painter.drawEllipse(QPointF(14.5*w,16.5*w*0.868),w+w*3,w+w*3);
painter.restore();
}
else
{
/* Draw all other symbols with rectangles */
int y=0;
for (int row=0;row<m_zintSymbol->rows;row++)
{
for (int i=0;i<m_zintSymbol->width;i++) {
if (module_set(row, i))
{
int ed = module_set(row, i);
int linewidth=0;
for (int j=i;j<m_zintSymbol->width;j++,linewidth++)
if (ed != module_set(row, j))
break;
QColor color;
color=m_fgColor;
if(!((i > main_width) && (row == m_zintSymbol->rows - 1))) {
painter.fillRect(i,y,linewidth,m_zintSymbol->row_height[row],QBrush(color));
} else {
painter.fillRect(i,y + 8,linewidth,m_zintSymbol->row_height[row] - 3,QBrush(color));
addon_text_height = y;
}
}
}
/* Add row binding */
if(((m_zintSymbol->symbology == BARCODE_CODE16K) || (m_zintSymbol->symbology == BARCODE_CODE49)) && (row != 0)) {
painter.fillRect(0,y - 1,m_zintSymbol->width,2,QBrush(m_fgColor));
}
y+=m_zintSymbol->row_height[row];
}
}
textdone = false;
if(m_hidetext == false) {
painter.setFont(fontSmall);
if(((m_zintSymbol->symbology == BARCODE_EANX) || (m_zintSymbol->symbology == BARCODE_EANX_CC)) ||
(m_zintSymbol->symbology == BARCODE_ISBNX)) {
/* Add bridge and format text for EAN */
switch(caption.size()) {
case 8:
case 11:
case 14:
painter.fillRect(0 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(2 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(32 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(34 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(64 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(66 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.setFont(fontLarge);
painter.drawText(3 + xoffset, m_zintSymbol->height + yoffset, 29, 9,Qt::AlignCenter, caption.mid(0,4));
painter.drawText(35 + xoffset, m_zintSymbol->height + yoffset, 29, 9,Qt::AlignCenter, caption.mid(4,4));
if(caption.size() == 11) { /* EAN-2 */ painter.drawText(76 + xoffset, addon_text_height, 20, 9,Qt::AlignCenter, caption.mid(9,2)); };
if(caption.size() == 14) { /* EAN-5 */ painter.drawText(76 + xoffset, addon_text_height, 47, 9,Qt::AlignCenter, caption.mid(9,5)); };
painter.setFont(fontSmall);
textdone = true;
break;
case 13:
case 16:
case 19:
painter.fillRect(0 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(2 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(46 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(48 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(92 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(94 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.setFont(fontLarge);
painter.drawText(xoffset - 7, m_zintSymbol->height + yoffset, 7, 9,Qt::AlignCenter, caption.mid(0,1));
painter.drawText(3 + xoffset, m_zintSymbol->height + yoffset, 43, 9,Qt::AlignCenter, caption.mid(1,6));
painter.drawText(49 + xoffset, m_zintSymbol->height + yoffset, 43, 9,Qt::AlignCenter, caption.mid(7,6));
if(caption.size() == 16) { /* EAN-2 */ painter.drawText(104 + xoffset, addon_text_height, 20, 9,Qt::AlignCenter, caption.mid(14,2)); };
if(caption.size() == 19) { /* EAN-5 */ painter.drawText(104 + xoffset, addon_text_height, 47, 9,Qt::AlignCenter, caption.mid(14,5)); };
painter.setFont(fontSmall);
textdone = true;
break;
}
if(textdone == false) {
painter.setFont(fontLarge);
painter.drawText(0, m_zintSymbol->height, m_zintSymbol->width, 9,Qt::AlignCenter, caption);
painter.setFont(fontSmall);
textdone = true;
}
}
if((m_zintSymbol->symbology == BARCODE_UPCA) || (m_zintSymbol->symbology == BARCODE_UPCA_CC)) {
/* Add bridge and format text for UPC-A */
int block_width;
bool latch = true;
j = 0 + comp_offset;
do {
block_width = 0;
do {
block_width++;
} while (module_set(m_zintSymbol->rows - 1, j + block_width) == module_set(m_zintSymbol->rows - 1, j));
if(latch == true) {
/* a bar */
painter.fillRect(j + xoffset - comp_offset,m_zintSymbol->height,block_width,5,QBrush(m_fgColor));
latch = false;
} else {
/* a space */
latch = true;
}
j += block_width;
} while (j < 11 + comp_offset);
painter.fillRect(46 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(48 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
latch = true;
j = 85 + comp_offset;
do {
block_width = 0;
do {
block_width++;
} while (module_set(m_zintSymbol->rows - 1, j + block_width) == module_set(m_zintSymbol->rows - 1, j));
if(latch == true) {
/* a bar */
painter.fillRect(j + xoffset - comp_offset,m_zintSymbol->height,block_width,5,QBrush(m_fgColor));
latch = false;
} else {
/* a space */
latch = true;
}
j += block_width;
} while (j < 96 + comp_offset);
painter.drawText(xoffset - 7, m_zintSymbol->height + yoffset + 2, 7, 7,Qt::AlignCenter, caption.mid(0,1));
painter.drawText(96 + xoffset, m_zintSymbol->height + yoffset + 2, 7, 7,Qt::AlignCenter, caption.mid(11,1));
painter.setFont(fontLarge);
painter.drawText(11 + xoffset, m_zintSymbol->height + yoffset, 35, 9,Qt::AlignCenter, caption.mid(1,5));
painter.drawText(49 + xoffset, m_zintSymbol->height + yoffset, 35, 9,Qt::AlignCenter, caption.mid(6,5));
if(caption.size() == 15) { /* EAN-2 */ painter.drawText(104 + xoffset, addon_text_height, 20, 9,Qt::AlignCenter, caption.mid(13,2)); };
if(caption.size() == 18) { /* EAN-5 */ painter.drawText(104 + xoffset, addon_text_height, 47, 9,Qt::AlignCenter, caption.mid(13,5)); };
painter.setFont(fontSmall);
textdone = true;
}
if((m_zintSymbol->symbology == BARCODE_UPCE) || (m_zintSymbol->symbology == BARCODE_UPCE_CC)) {
/* Add bridge and format text for UPC-E */
painter.fillRect(0 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(2 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(46 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(48 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.fillRect(50 + xoffset,m_zintSymbol->height,1,5,QBrush(m_fgColor));
painter.drawText(xoffset - 7, m_zintSymbol->height + yoffset + 2, 7, 7,Qt::AlignCenter, caption.mid(0,1));
painter.drawText(51 + xoffset, m_zintSymbol->height + yoffset + 2, 7, 7,Qt::AlignCenter, caption.mid(7,1));
painter.setFont(fontLarge);
painter.drawText(3 + xoffset, m_zintSymbol->height + yoffset, 43, 9,Qt::AlignCenter, caption.mid(1,6));
if(caption.size() == 11) { /* EAN-2 */ painter.drawText(60 + xoffset, addon_text_height, 20, 9,Qt::AlignCenter, caption.mid(9,2)); };
if(caption.size() == 14) { /* EAN-2 */ painter.drawText(60 + xoffset, addon_text_height, 47, 9,Qt::AlignCenter, caption.mid(9,5)); };
painter.setFont(fontSmall);
textdone = true;
}
} /* if (m_hidetext == false) */
if((m_hidetext == false) && (textdone == false)) {
/* Add text to any other symbol */
painter.drawText(0, m_zintSymbol->height + yoffset, m_zintSymbol->width, 7, Qt::AlignCenter, caption);
}
painter.restore();
}
void ModelScene::refresh()
{
// clear existing scene
// clear model items
for (ModelItemGraphics* MItemG : m_GraphicsItems)
{
removeItem(MItemG);
delete MItemG;
}
m_GraphicsItems.clear();
// clear connections
for (ConnectorGraphics* ConnG : m_GraphicsConnections)
{
removeItem(ConnG);
delete ConnG;
}
m_GraphicsConnections.clear();
clear();
const std::list<openfluid::fluidx::ModelItemDescriptor*>& Items = m_Model.items();
std::list<openfluid::fluidx::ModelItemDescriptor*>::const_iterator itb = Items.begin();
std::list<openfluid::fluidx::ModelItemDescriptor*>::const_iterator ite = Items.end();
std::list<openfluid::fluidx::ModelItemDescriptor*>::const_iterator it;
unsigned int SimCount = 0;
unsigned int GenCount = 0;
// add model items
for (it = itb; it!= ite; ++it)
{
if ((*it)->isEnabled())
{
QString ID = QString::fromStdString(m_Model.getID(*it));
QVariant ConfigPos =
openfluid::base::RunContextManager::instance()->getProjectConfigValue("builder.model.graphicalview",ID);
QPoint Position(0,0);
if (ConfigPos.type() == QVariant::Point)
Position = ConfigPos.toPoint();
else
{
QRectF CurrentRect = itemsBoundingRect();
Position.setX(int(CurrentRect.x()+CurrentRect.width()/2));
Position.setY(int(CurrentRect.y()+CurrentRect.height()/2));
}
if ((*it)->getType() == openfluid::ware::WareType::SIMULATOR &&
openfluid::machine::SimulatorSignatureRegistry::instance()->isSimulatorAvailable(ID.toStdString()))
{
SimCount++;
SimulatorGraphics* SimG =
new SimulatorGraphics(QPoint(0,0),
ID, SimCount+GenCount,
openfluid::machine::SimulatorSignatureRegistry::instance()
->signature(ID.toStdString()));
addItem(SimG);
SimG->moveBy(Position.x(),Position.y());
SimG->initialize();
m_GraphicsItems.append(SimG);
connect(SimG,SIGNAL(srcEditAsked(const QString&,bool)),this,SLOT(notifySrcEditAsked(const QString&,bool)));
}
else if ((*it)->getType() == openfluid::ware::WareType::GENERATOR)
void QwtScaleWidget::drawTitle( QPainter *painter,
QwtScaleDraw::Alignment align, const QRectF &rect ) const
{
QRectF r = rect;
double angle;
int flags = d_data->title.renderFlags() &
~( Qt::AlignTop | Qt::AlignBottom | Qt::AlignVCenter );
switch ( align )
{
case QwtScaleDraw::LeftScale:
angle = -90.0;
flags |= Qt::AlignTop;
r.setRect( r.left(), r.bottom(),
r.height(), r.width() - d_data->titleOffset );
break;
case QwtScaleDraw::RightScale:
angle = -90.0;
flags |= Qt::AlignTop;
r.setRect( r.left() + d_data->titleOffset, r.bottom(),
r.height(), r.width() - d_data->titleOffset );
break;
case QwtScaleDraw::BottomScale:
angle = 0.0;
flags |= Qt::AlignBottom;
r.setTop( r.top() + d_data->titleOffset );
break;
case QwtScaleDraw::TopScale:
default:
angle = 0.0;
flags |= Qt::AlignTop;
r.setBottom( r.bottom() - d_data->titleOffset );
break;
}
if ( d_data->layoutFlags & TitleInverted )
{
if ( align == QwtScaleDraw::LeftScale
|| align == QwtScaleDraw::RightScale )
{
angle = -angle;
r.setRect( r.x() + r.height(), r.y() - r.width(),
r.width(), r.height() );
}
}
painter->save();
painter->setFont( font() );
painter->setPen( palette().color( QPalette::Text ) );
painter->translate( r.x(), r.y() );
if ( angle != 0.0 )
painter->rotate( angle );
QwtText title = d_data->title;
title.setRenderFlags( flags );
title.draw( painter, QRectF( 0.0, 0.0, r.width(), r.height() ) );
painter->restore();
}
void PianoView::drawBackground(QPainter* p, const QRectF& r)
{
if (staff == 0)
return;
Score* _score = staff->score();
setFrameShape(QFrame::NoFrame);
QRectF r1;
r1.setCoords(-1000000.0, 0.0, 480.0, 1000000.0);
QRectF r2;
r2.setCoords(ticks + MAP_OFFSET, 0.0, 1000000.0, 1000000.0);
QColor bg(0x71, 0x8d, 0xbe);
p->fillRect(r, bg);
if (r.intersects(r1))
p->fillRect(r.intersected(r1), bg.darker(150));
if (r.intersects(r2))
p->fillRect(r.intersected(r2), bg.darker(150));
//
// draw horizontal grid lines
//
qreal y1 = r.y();
qreal y2 = y1 + r.height();
qreal kh = 13.0;
qreal x1 = r.x();
qreal x2 = x1 + r.width();
// int key = floor(y1 / 75);
int key = floor(y1 / kh);
qreal y = key * kh;
for (; key < 75; ++key, y += kh) {
if (y < y1)
continue;
if (y > y2)
break;
p->setPen(QPen((key % 7) == 5 ? Qt::lightGray : Qt::gray));
p->drawLine(QLineF(x1, y, x2, y));
}
//
// draw vertical grid lines
//
static const int mag[7] = {
1, 1, 2, 5, 10, 20, 50
};
Pos pos1 = pix2pos(x1);
Pos pos2 = pix2pos(x2);
//---------------------------------------------------
// draw raster
//---------------------------------------------------
int bar1, bar2, beat, tick;
pos1.mbt(&bar1, &beat, &tick);
pos2.mbt(&bar2, &beat, &tick);
int n = mag[magStep < 0 ? 0 : magStep];
bar1 = (bar1 / n) * n; // round down
if (bar1 && n >= 2)
bar1 -= 1;
bar2 = ((bar2 + n - 1) / n) * n; // round up
for (int bar = bar1; bar <= bar2;) {
Pos stick(_score->tempomap(), _score->sigmap(), bar, 0, 0);
if (magStep > 0) {
double x = double(pos2pix(stick));
if (x > 0) {
p->setPen(QPen(Qt::lightGray, 0.0));
p->drawLine(x, y1, x, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(x, y1, x, y1);
}
}
else {
int z = stick.timesig().timesig().numerator();
for (int beat = 0; beat < z; beat++) {
if (magStep == 0) {
Pos xx(_score->tempomap(), _score->sigmap(), bar, beat, 0);
int xp = pos2pix(xx);
if (xp < 0)
continue;
if (xp > 0) {
p->setPen(QPen(beat == 0 ? Qt::lightGray : Qt::gray, 0.0));
p->drawLine(xp, y1, xp, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(xp, y1, xp, y2);
}
}
else {
int k;
if (magStep == -1)
k = 2;
else if (magStep == -2)
k = 4;
else if (magStep == -3)
k = 8;
else if (magStep == -4)
k = 16;
else
k = 32;
int n = (MScore::division * 4) / stick.timesig().timesig().denominator();
for (int i = 0; i < k; ++i) {
Pos xx(_score->tempomap(), _score->sigmap(), bar, beat, (n * i)/ k);
int xp = pos2pix(xx);
if (xp < 0)
continue;
if (xp > 0) {
p->setPen(QPen(i == 0 && beat == 0 ? Qt::lightGray : Qt::gray, 0.0));
p->drawLine(xp, y1, xp, y2);
}
else {
p->setPen(QPen(Qt::black, 0.0));
p->drawLine(xp, y1, xp, y2);
}
}
}
}
}
if (bar == 0 && n >= 2)
bar += (n-1);
else
bar += n;
}
}
void QSGPropertyAnimator::updateProperty(QObject *target, const QString& p)
{
QSGAnimatedProperty *ap = m_controller->registeredProperty(p, target);
if (ap && m_duration > 0) {
if (m_elapsed > m_startTime && ((m_elapsed < m_startTime + m_loops * m_duration) || (m_loops < 0))) {
QVariant value = ap->value();
qreal tx = int(m_elapsed - m_startTime) % int(m_duration);
switch (value.type()) {
case QMetaType::Double:
value = QVariant(m_from.toReal() + (m_to.toReal() - m_from.toReal()) * m_easing.valueForProgress(tx / m_duration));
break;
case QMetaType::QColor:
{
QColor from = qvariant_cast<QColor>(m_from);
QColor to = qvariant_cast<QColor>(m_to);
QColor result = qvariant_cast<QColor>(value);
result.setRed(from.red() + (to.red() - from.red()) * m_easing.valueForProgress(tx / m_duration));
result.setGreen(from.green() + (to.green() - from.green()) * m_easing.valueForProgress(tx / m_duration));
result.setBlue(from.blue() + (to.blue() - from.blue()) * m_easing.valueForProgress(tx / m_duration));
result.setAlpha(from.alpha() + (to.alpha() - from.alpha()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::Int:
value = QVariant(m_from.toInt() + (m_to.toInt() - m_from.toInt()) * m_easing.valueForProgress(tx / m_duration));
break;
case QMetaType::QSize:
{
QSize from = m_from.toSize();
QSize to = m_to.toSize();
QSize result = value.toSize();
result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QSizeF:
{
QSizeF from = m_from.toSize();
QSizeF to = m_to.toSize();
QSizeF result = value.toSize();
result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QPoint:
{
QPoint from = m_from.toPoint();
QPoint to = m_to.toPoint();
QPoint result = value.toPoint();
result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QPointF:
{
QPointF from = m_from.toPointF();
QPointF to = m_to.toPointF();
QPointF result = value.toPointF();
result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QRect:
{
QRect from = m_from.toRect();
QRect to = m_to.toRect();
QRect result = value.toRect();
result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QRectF:
{
QRectF from = m_from.toRectF();
QRectF to = m_to.toRectF();
QRectF result = value.toRectF();
result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
result.setWidth(from.width() + (to.width() - from.width()) * m_easing.valueForProgress(tx / m_duration));
result.setHeight(from.height() + (to.height() - from.height()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
case QMetaType::QVector3D:
{
QVector3D from = qvariant_cast<QVector3D>(m_from);
QVector3D to = qvariant_cast<QVector3D>(m_to);
QVector3D result = qvariant_cast<QVector3D>(value);
result.setX(from.x() + (to.x() - from.x()) * m_easing.valueForProgress(tx / m_duration));
result.setY(from.y() + (to.y() - from.y()) * m_easing.valueForProgress(tx / m_duration));
result.setZ(from.z() + (to.z() - from.z()) * m_easing.valueForProgress(tx / m_duration));
value = result;
break;
}
default:
break;
}
ap->setValue(value);
}
}
}
void MandelbrotWidget::paintEvent(QPaintEvent * /* event */)
{
QPainter painter(this);
painter.fillRect(rect(), Qt::black);
if (instances[0].pixmap.isNull()) {
painter.setPen(Qt::white);
painter.drawText(rect(), Qt::AlignCenter,
tr("Rendering initial image, please wait..."));
return;
}
int textWidth, pointCur;
QRectF screen;
QString textStat;
QRectF wholescreen = QRectF(0, 0, this->width(), this->height()); //Amir
QFontMetrics metrics = painter.fontMetrics();
for (int rowCur=0; rowCur< rowMax; rowCur++) //Amir
for (int colCur=0; colCur< colMax; colCur++) //Amir
{
pointCur = rowCur * colMax + colCur;
screen = QRectF(colCur * this->width() / colMax, rowCur * this->height() / rowMax,
this->width() / colMax - borderThreshold , this->height() / rowMax - borderThreshold); //Amir
if (instances[pointCur].curScale == instances[pointCur].pixmapScale) {
// painter.drawPixmap(pixmapOffset, pixmap);
painter.drawPixmap(screen, instances[pointCur].pixmap, wholescreen); //Amir
} else {
// double scaleFactor = pixmapScale / curScale;
// int newWidth = int(pixmap[pointCur].width() * scaleFactor);
// int newHeight = int(pixmap[pointCur].height() * scaleFactor);
// int newX = pixmapOffset.x() + (pixmap[pointCur].width() - newWidth) / 2;
// int newY = pixmapOffset.y() + (pixmap[pointCur].height() - newHeight) / 2;
painter.save();
// painter.translate(newX, newY);
// painter.scale(scaleFactor, scaleFactor);
// QRectF exposed = painter.matrix().inverted().mapRect(rect()).adjusted(-1, -1, 1, 1);
painter.drawPixmap(screen, instances[pointCur].pixmap, wholescreen); //Amir
//painter.drawPixmap(exposed, pixmap, exposed);
painter.restore();
}
if (instances[pointCur].renderingDone)
{
textStat = tr("Process Done");
textWidth = metrics.width(textStat);
}
else
{
textStat = tr("Process Pass ") + QString(instances[pointCur].renderingDoneLevel+0x30);
textWidth = metrics.width(textStat);
}
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 127));
painter.drawRect(screen.x(),
screen.y() + screen.height() -20,
100,
20);
painter.setPen(Qt::white);
painter.drawText(screen.x() + 3,
screen.y() + screen.height() - 5,
textStat);
}
QString text = tr("Use mouse wheel or the '+' and '-' keys to zoom. "
"Press and hold left mouse button to scroll.");
// QFontMetrics metrics = painter.fontMetrics();
textWidth = metrics.width(text);
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 127));
painter.drawRect((width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5);
painter.setPen(Qt::white);
painter.drawText((width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text);
}
void Worker::run() {
while (1) {
res->requestSemaphore.acquire(1);
if (die) {
break;
}
// get next page to render
res->requestMutex.lock();
int page, width, index;
map<int,pair<int,int> >::iterator less = res->requests.lower_bound(res->center_page);
map<int,pair<int,int> >::iterator greater = less--;
if (greater != res->requests.end()) {
if (greater != res->requests.begin()) {
// favour nearby page, go down first
if (greater->first + less->first <= res->center_page * 2) {
page = greater->first;
index = greater->second.first;
width = greater->second.second;
res->requests.erase(greater);
} else {
page = less->first;
index = less->second.first;
width = less->second.second;
res->requests.erase(less);
}
} else {
page = greater->first;
index = greater->second.first;
width = greater->second.second;
res->requests.erase(greater);
}
} else {
page = less->first;
index = less->second.first;
width = less->second.second;
res->requests.erase(less);
}
res->requestMutex.unlock();
// check for duplicate requests
res->k_page[page].mutex.lock();
if (res->k_page[page].status[index] == width &&
res->k_page[page].rotation[index] == res->rotation) {
res->k_page[page].mutex.unlock();
continue;
}
int rotation = res->rotation;
res->k_page[page].mutex.unlock();
// open page
#ifdef DEBUG
cerr << " rendering page " << page << " for index " << index << endl;
#endif
Poppler::Page *p = res->doc->page(page);
if (p == NULL) {
cerr << "failed to load page " << page << endl;
continue;
}
// render page
float dpi = 72.0 * width / res->get_page_width(page);
QImage img = p->renderToImage(dpi, dpi, -1, -1, -1, -1,
static_cast<Poppler::Page::Rotation>(rotation));
if (img.isNull()) {
cerr << "failed to render page " << page << endl;
continue;
}
// invert to current color setting
if (res->inverted_colors) {
img.invertPixels();
}
// put page
res->k_page[page].mutex.lock();
if (!res->k_page[page].img[index].isNull()) {
res->k_page[page].img[index] = QImage(); // assign null image
}
// adjust all available images to current color setting
if (res->k_page[page].inverted_colors != res->inverted_colors) {
res->k_page[page].inverted_colors = res->inverted_colors;
for (int i = 0; i < 3; i++) {
res->k_page[page].img[i].invertPixels();
}
res->k_page[page].thumbnail.invertPixels();
}
res->k_page[page].img[index] = img;
res->k_page[page].status[index] = width;
res->k_page[page].rotation[index] = rotation;
res->k_page[page].mutex.unlock();
res->garbageMutex.lock();
res->garbage.insert(page); // TODO add index information?
res->garbageMutex.unlock();
emit page_rendered(page);
// collect goto links
res->link_mutex.lock();
if (res->k_page[page].links == NULL) {
res->link_mutex.unlock();
QList<Poppler::Link *> *links = new QList<Poppler::Link *>;
QList<Poppler::Link *> l = p->links();
links->swap(l);
res->link_mutex.lock();
res->k_page[page].links = links;
}
if (res->k_page[page].text == NULL) {
res->link_mutex.unlock();
QList<Poppler::TextBox *> text = p->textList();
// assign boxes to lines
// make single parts from chained boxes
set<Poppler::TextBox *> used;
QList<SelectionPart *> selection_parts;
Q_FOREACH(Poppler::TextBox *box, text) {
if (used.find(box) != used.end()) {
continue;
}
used.insert(box);
SelectionPart *p = new SelectionPart(box);
selection_parts.push_back(p);
Poppler::TextBox *next = box->nextWord();
while (next != NULL) {
used.insert(next);
p->add_word(next);
next = next->nextWord();
}
}
// sort by y coordinate
qStableSort(selection_parts.begin(), selection_parts.end(), selection_less_y);
QRectF line_box;
QList<SelectionLine *> *lines = new QList<SelectionLine *>();
Q_FOREACH(SelectionPart *part, selection_parts) {
QRectF box = part->get_bbox();
// box fits into line_box's line
if (!lines->empty() && box.y() <= line_box.center().y() && box.bottom() > line_box.center().y()) {
float ratio_w = box.width() / line_box.width();
float ratio_h = box.height() / line_box.height();
if (ratio_w < 1.0f) {
ratio_w = 1.0f / ratio_w;
}
if (ratio_h < 1.0f) {
ratio_h = 1.0f / ratio_h;
}
if (ratio_w > 1.3f && ratio_h > 1.3f) {
lines->back()->sort();
lines->push_back(new SelectionLine(part));
line_box = part->get_bbox();
} else {
lines->back()->add_part(part);
}
// it doesn't fit, create new line
} else {
if (!lines->empty()) {
lines->back()->sort();
}
lines->push_back(new SelectionLine(part));
line_box = part->get_bbox();
}
}
if (!lines->empty()) {
lines->back()->sort();
}
res->link_mutex.lock();
res->k_page[page].text = lines;
}
/**
* This benchmark runs a series of huge strokes on a canvas with a
* particular configuration of the swapper/pooler and history
* management. After the test is done you can visualize the results
* with the GNU Octave. Please use kis_low_memory_show_report.m file
* for that.
*/
void KisLowMemoryBenchmark::benchmarkWideArea(const QString presetFileName,
const QRectF &rect, qreal vstep,
int numCycles,
bool createTransaction,
int hardLimitMiB,
int softLimitMiB,
int poolLimitMiB,
int index)
{
KisPaintOpPresetSP preset = new KisPaintOpPreset(QString(FILES_DATA_DIR) + QDir::separator() + presetFileName);
LOAD_PRESET_OR_RETURN(preset, presetFileName);
/**
* Initialize image and painter
*/
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, HUGE_IMAGE_SIZE, HUGE_IMAGE_SIZE, colorSpace, "stroke sample image");
KisLayerSP layer = new KisPaintLayer(image, "temporary for stroke sample", OPACITY_OPAQUE_U8, colorSpace);
KisLayerSP layerExtra = new KisPaintLayer(image, "temporary for threading", OPACITY_OPAQUE_U8, colorSpace);
image->addNode(layer, image->root());
image->addNode(layerExtra, image->root());
KisPainter *painter = new KisPainter(layer->paintDevice());
painter->setPaintColor(KoColor(Qt::black, colorSpace));
painter->setPaintOpPreset(preset, layer, image);
/**
* A simple adapter that will store all the transactions for us
*/
KisSurrogateUndoAdapter undoAdapter;
/**
* Reset configuration to the desired settings
*/
KisImageConfig config;
qreal oldHardLimit = config.memoryHardLimitPercent();
qreal oldSoftLimit = config.memorySoftLimitPercent();
qreal oldPoolLimit = config.memoryPoolLimitPercent();
const qreal _MiB = 100.0 / KisImageConfig::totalRAM();
config.setMemoryHardLimitPercent(hardLimitMiB * _MiB);
config.setMemorySoftLimitPercent(softLimitMiB * _MiB);
config.setMemoryPoolLimitPercent(poolLimitMiB * _MiB);
KisTileDataStore::instance()->testingRereadConfig();
/**
* Create an empty the log file
*/
QString fileName;
fileName = QString("log_%1_%2_%3_%4_%5.txt")
.arg(createTransaction)
.arg(hardLimitMiB)
.arg(softLimitMiB)
.arg(poolLimitMiB)
.arg(index);
QFile logFile(fileName);
logFile.open(QFile::WriteOnly | QFile::Truncate);
QTextStream logStream(&logFile);
logStream.setFieldWidth(10);
logStream.setFieldAlignment(QTextStream::AlignRight);
/**
* Start painting on the image
*/
QTime cycleTime;
QTime lineTime;
cycleTime.start();
lineTime.start();
qreal rectBottom = rect.y() + rect.height();
for (int i = 0; i < numCycles; i++) {
cycleTime.restart();
QLineF line(rect.topLeft(), rect.topLeft() + QPointF(rect.width(), 0));
if (createTransaction) {
painter->beginTransaction();
}
KisDistanceInformation currentDistance;
while(line.y1() < rectBottom) {
lineTime.restart();
KisPaintInformation pi1(line.p1(), 0.0);
KisPaintInformation pi2(line.p2(), 1.0);
painter->paintLine(pi1, pi2, ¤tDistance);
painter->device()->setDirty(painter->takeDirtyRegion());
logStream << "L 1" << i << lineTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction << endl;
line.translate(0, vstep);
}
painter->device()->setDirty(painter->takeDirtyRegion());
if (createTransaction) {
painter->endTransaction(&undoAdapter);
}
// comment/uncomment to emulate user waiting after the stroke
QTest::qSleep(1000);
logStream << "C 2" << i << cycleTime.elapsed()
<< KisTileDataStore::instance()->numTilesInMemory() * 16
<< KisTileDataStore::instance()->numTiles() * 16
<< createTransaction
<< config.memoryHardLimitPercent() / _MiB
<< config.memorySoftLimitPercent() / _MiB
<< config.memoryPoolLimitPercent() / _MiB << endl;
}
config.setMemoryHardLimitPercent(oldHardLimit * _MiB);
config.setMemorySoftLimitPercent(oldSoftLimit * _MiB);
config.setMemoryPoolLimitPercent(oldPoolLimit * _MiB);
delete painter;
}
rect drawing_context::get_fill_extents()
{
QRectF rect = path_.boundingRect();
return {{float(rect.x()), float(rect.y())},
{float(rect.width()), float(rect.height())}};
}
int GraphPathRenderer::needRedraw(QRectF tileRect)
{
TileManager *tm = m_data->tiles;
int index = tm->get_tile_num(tileRect.x(), tileRect.y());
return m_data->redrawFlags[index];
}
// Apply a simple variant type to a DOM property
static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop)
{
switch (v.type()) {
case QVariant::String: {
DomString *str = new DomString();
str->setText(v.toString());
if (!translateString)
str->setAttributeNotr(QStringLiteral("true"));
dom_prop->setElementString(str);
}
return true;
case QVariant::ByteArray:
dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray()));
return true;
case QVariant::Int:
dom_prop->setElementNumber(v.toInt());
return true;
case QVariant::UInt:
dom_prop->setElementUInt(v.toUInt());
return true;
case QVariant::LongLong:
dom_prop->setElementLongLong(v.toLongLong());
return true;
case QVariant::ULongLong:
dom_prop->setElementULongLong(v.toULongLong());
return true;
case QVariant::Double:
dom_prop->setElementDouble(v.toDouble());
return true;
case QVariant::Bool:
dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue);
return true;
case QVariant::Char: {
DomChar *ch = new DomChar();
const QChar character = v.toChar();
ch->setElementUnicode(character.unicode());
dom_prop->setElementChar(ch);
}
return true;
case QVariant::Point: {
DomPoint *pt = new DomPoint();
const QPoint point = v.toPoint();
pt->setElementX(point.x());
pt->setElementY(point.y());
dom_prop->setElementPoint(pt);
}
return true;
case QVariant::PointF: {
DomPointF *ptf = new DomPointF();
const QPointF pointf = v.toPointF();
ptf->setElementX(pointf.x());
ptf->setElementY(pointf.y());
dom_prop->setElementPointF(ptf);
}
return true;
case QVariant::Color: {
DomColor *clr = new DomColor();
const QColor color = qvariant_cast<QColor>(v);
clr->setElementRed(color.red());
clr->setElementGreen(color.green());
clr->setElementBlue(color.blue());
const int alphaChannel = color.alpha();
if (alphaChannel != 255)
clr->setAttributeAlpha(alphaChannel);
dom_prop->setElementColor(clr);
}
return true;
case QVariant::Size: {
DomSize *sz = new DomSize();
const QSize size = v.toSize();
sz->setElementWidth(size.width());
sz->setElementHeight(size.height());
dom_prop->setElementSize(sz);
}
return true;
case QVariant::SizeF: {
DomSizeF *szf = new DomSizeF();
const QSizeF sizef = v.toSizeF();
szf->setElementWidth(sizef.width());
szf->setElementHeight(sizef.height());
dom_prop->setElementSizeF(szf);
}
return true;
case QVariant::Rect: {
DomRect *rc = new DomRect();
const QRect rect = v.toRect();
rc->setElementX(rect.x());
rc->setElementY(rect.y());
rc->setElementWidth(rect.width());
rc->setElementHeight(rect.height());
dom_prop->setElementRect(rc);
}
return true;
case QVariant::RectF: {
DomRectF *rcf = new DomRectF();
const QRectF rectf = v.toRectF();
rcf->setElementX(rectf.x());
rcf->setElementY(rectf.y());
rcf->setElementWidth(rectf.width());
rcf->setElementHeight(rectf.height());
dom_prop->setElementRectF(rcf);
}
return true;
case QVariant::Font: {
DomFont *fnt = new DomFont();
const QFont font = qvariant_cast<QFont>(v);
const uint mask = font.resolve();
if (mask & QFont::WeightResolved) {
fnt->setElementBold(font.bold());
fnt->setElementWeight(font.weight());
}
if (mask & QFont::FamilyResolved)
fnt->setElementFamily(font.family());
if (mask & QFont::StyleResolved)
fnt->setElementItalic(font.italic());
if (mask & QFont::SizeResolved)
fnt->setElementPointSize(font.pointSize());
if (mask & QFont::StrikeOutResolved)
fnt->setElementStrikeOut(font.strikeOut());
if (mask & QFont::UnderlineResolved)
fnt->setElementUnderline(font.underline());
if (mask & QFont::KerningResolved)
fnt->setElementKerning(font.kerning());
if (mask & QFont::StyleStrategyResolved) {
const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy");
fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy())));
}
dom_prop->setElementFont(fnt);
}
return true;
#ifndef QT_NO_CURSOR
case QVariant::Cursor: {
const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape");
dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape())));
}
return true;
#endif
case QVariant::KeySequence: {
DomString *s = new DomString();
s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText));
dom_prop->setElementString(s);
}
return true;
case QVariant::Locale: {
DomLocale *dom = new DomLocale();
const QLocale locale = qvariant_cast<QLocale>(v);
const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language");
const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country");
dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language())));
dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country())));
dom_prop->setElementLocale(dom);
}
return true;
case QVariant::SizePolicy: {
DomSizePolicy *dom = new DomSizePolicy();
const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v);
dom->setElementHorStretch(sizePolicy.horizontalStretch());
dom->setElementVerStretch(sizePolicy.verticalStretch());
const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType");
dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy())));
dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy())));
dom_prop->setElementSizePolicy(dom);
}
return true;
case QVariant::Date: {
DomDate *dom = new DomDate();
const QDate date = qvariant_cast<QDate>(v);
dom->setElementYear(date.year());
dom->setElementMonth(date.month());
dom->setElementDay(date.day());
dom_prop->setElementDate(dom);
}
return true;
case QVariant::Time: {
DomTime *dom = new DomTime();
const QTime time = qvariant_cast<QTime>(v);
dom->setElementHour(time.hour());
dom->setElementMinute(time.minute());
dom->setElementSecond(time.second());
dom_prop->setElementTime(dom);
}
return true;
case QVariant::DateTime: {
DomDateTime *dom = new DomDateTime();
const QDateTime dateTime = qvariant_cast<QDateTime>(v);
dom->setElementHour(dateTime.time().hour());
dom->setElementMinute(dateTime.time().minute());
dom->setElementSecond(dateTime.time().second());
dom->setElementYear(dateTime.date().year());
dom->setElementMonth(dateTime.date().month());
dom->setElementDay(dateTime.date().day());
dom_prop->setElementDateTime(dom);
}
return true;
case QVariant::Url: {
DomUrl *dom = new DomUrl();
const QUrl url = v.toUrl();
DomString *str = new DomString();
str->setText(url.toString());
dom->setElementString(str);
dom_prop->setElementUrl(dom);
}
return true;
case QVariant::StringList: {
DomStringList *sl = new DomStringList;
sl->setElementString(qvariant_cast<QStringList>(v));
dom_prop->setElementStringList(sl);
}
return true;
default:
break;
}
return false;
}
void setRect( const QRectF& rc ) {
rect_ = QRect( int( rc.x() ), int( rc.y() ), int( rc.width() + 1 ), int( rc.height() + 1 ) );
}
void ContentWindowGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent * event)
{
// on Mac we've seen that mouse events can go to the wrong graphics item
// this is due to the bug: https://bugreports.qt.nokia.com/browse/QTBUG-20493
// here we ignore the event if it shouldn't have been sent to us, which ensures
// it will go to the correct item...
if(boundingRect().contains(event->pos()) == false)
{
event->ignore();
return;
}
// button dimensions
float buttonWidth, buttonHeight;
getButtonDimensions(buttonWidth, buttonHeight);
// item rectangle and event position
QRectF r = boundingRect();
QPointF eventPos = event->pos();
// check to see if user clicked on the close button
if(fabs((r.x()+r.width()) - eventPos.x()) <= buttonWidth &&
fabs(r.y() - eventPos.y()) <= buttonHeight)
{
close();
return;
}
// move to the front of the GUI display
moveToFront();
ContentWindowManagerPtr contentWindow = getContentWindowManager();
if (!contentWindow)
return;
if (selected())
{
contentWindow->getInteractionDelegate().mousePressEvent(event);
return;
}
contentWindow->getContent()->blockAdvance( true );
// check to see if user clicked on the resize button
if(fabs((r.x()+r.width()) - eventPos.x()) <= buttonWidth &&
fabs((r.y()+r.height()) - eventPos.y()) <= buttonHeight)
{
resizing_ = true;
}
// check to see if user clicked on the fullscreen button
else if(fabs(r.x() - eventPos.x()) <= buttonWidth &&
fabs((r.y()+r.height()) - eventPos.y()) <= buttonHeight)
{
toggleFullscreen();
}
else if(fabs(((r.x()+r.width())/2) - eventPos.x() - buttonWidth) <= buttonWidth &&
fabs((r.y()+r.height()) - eventPos.y()) <= buttonHeight &&
g_configuration->getOptions()->getShowMovieControls( ))
{
contentWindow->setControlState( ControlState(contentWindow->getControlState() ^ STATE_PAUSED) );
}
else if(fabs(((r.x()+r.width())/2) - eventPos.x()) <= buttonWidth &&
fabs((r.y()+r.height()) - eventPos.y()) <= buttonHeight &&
g_configuration->getOptions()->getShowMovieControls( ))
{
contentWindow->setControlState( ControlState(contentWindow->getControlState() ^ STATE_LOOP) );
}
else
moving_ = true;
QGraphicsItem::mousePressEvent(event);
}
void
FlowDesigner::paintComponentLinks(QPainter *painter, const QRectF &bounds,
const Component &comp) {
QFontMetrics metrics = painter->fontMetrics();
QPen pen(Qt::red, 1);
QBrush brush(Qt::red);
painter->setPen(pen);
float xPos = 0;
float yPos = 0;
// Draw any connections
QPainterPath linkPath;
int idx = 0;
for (Port *port : comp.getPorts()) {
const std::set<Port *> &connections = port->getConnections();
if (connections.size() > 0) {
QRectF portBounds = calculatePortBoundingBox(*port, bounds);
for (const Port *conn : connections) {
// Determine who should draw the link
if (comp.getProperty("id") > conn->getComponent()->getProperty("id")) continue;
QRectF receivingCompBounds = calculateBoundingBox(*conn->getComponent());
QRectF receivingBounds = calculatePortBoundingBox(*conn,
receivingCompBounds);
float startX = portBounds.x() + 0.5f * portBounds.width();
float startY = portBounds.y() + 0.5f * portBounds.height();
float endX = receivingBounds.x() + 0.5f * receivingBounds.width();
float endY = receivingBounds.y() + 0.5f * receivingBounds.height();
float middleX = (startX + endX) / 2;
float middleY = (startY + endY) / 2;
linkPath.moveTo(startX, startY);
linkPath.cubicTo(startX, startY, middleX, startY, middleX, middleY);
linkPath.cubicTo(middleX, middleY, middleX, endY, endX, endY);
}
}
idx++;
}
painter->drawPath(linkPath);
//
// Now draw the input/output circles
//
QPainterPath circlePath;
QPainterPath circlePathFilled;
idx = 0;
for (Port *port : comp.getPorts()) {
QString text = QString::fromStdString(port->getName());
QRectF portBounds = calculatePortBoundingBox(*port, bounds);
if (port->isConnected()) {
circlePathFilled.addEllipse(portBounds);
} else {
circlePath.addEllipse(portBounds);
}
idx++;
}
painter->drawPath(circlePath);
painter->fillPath(circlePathFilled, brush);
}
/*!
\brief Draw the raster data
\param painter Painter
\param xMap X-Scale Map
\param yMap Y-Scale Map
\param canvasRect Contents rectangle of the plot canvas
*/
void QwtPlotRasterItem::draw( QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &canvasRect ) const
{
if ( canvasRect.isEmpty() || d_data->alpha == 0 )
return;
const bool doCache = qwtUseCache( d_data->cache.policy, painter );
const QwtInterval xInterval = interval( Qt::XAxis );
const QwtInterval yInterval = interval( Qt::YAxis );
/*
Scaling an image always results in a loss of
precision/quality. So we always render the image in
paint device resolution.
*/
QwtScaleMap xxMap, yyMap;
qwtTransformMaps( painter->transform(), xMap, yMap, xxMap, yyMap );
QRectF paintRect = painter->transform().mapRect( canvasRect );
QRectF area = QwtScaleMap::invTransform( xxMap, yyMap, paintRect );
const QRectF br = boundingRect();
if ( br.isValid() && !br.contains( area ) )
{
area &= br;
if ( !area.isValid() )
return;
paintRect = QwtScaleMap::transform( xxMap, yyMap, area );
}
QRectF imageRect;
QImage image;
QRectF pixelRect = pixelHint(area);
if ( !pixelRect.isEmpty() )
{
// pixel in target device resolution
const double dx = qAbs( xxMap.invTransform( 1 ) - xxMap.invTransform( 0 ) );
const double dy = qAbs( yyMap.invTransform( 1 ) - yyMap.invTransform( 0 ) );
if ( dx > pixelRect.width() && dy > pixelRect.height() )
{
/*
When the resolution of the data pixels is higher than
the resolution of the target device we render in
target device resolution.
*/
pixelRect = QRectF();
}
}
if ( pixelRect.isEmpty() )
{
if ( QwtPainter::roundingAlignment( painter ) )
{
// we want to have maps, where the boundaries of
// the aligned paint rectangle exactly match the area
paintRect = qwtAlignRect(paintRect);
qwtAdjustMaps(xxMap, yyMap, area, paintRect);
}
// When we have no information about position and size of
// data pixels we render in resolution of the paint device.
image = compose(xxMap, yyMap,
area, paintRect, paintRect.size().toSize(), doCache);
if ( image.isNull() )
return;
// Remove pixels at the boundaries, when explicitly
// excluded in the intervals
imageRect = qwtStripRect(paintRect, area,
xxMap, yyMap, xInterval, yInterval);
if ( imageRect != paintRect )
{
const QRect r(
qRound( imageRect.x() - paintRect.x()),
qRound( imageRect.y() - paintRect.y() ),
qRound( imageRect.width() ),
qRound( imageRect.height() ) );
image = image.copy(r);
}
}
else
{
if ( QwtPainter::roundingAlignment( painter ) )
paintRect = qwtAlignRect(paintRect);
// align the area to the data pixels
QRectF imageArea = qwtExpandToPixels(area, pixelRect);
if ( imageArea.right() == xInterval.maxValue() &&
!( xInterval.borderFlags() & QwtInterval::ExcludeMaximum ) )
{
imageArea.adjust(0, 0, pixelRect.width(), 0);
}
if ( imageArea.bottom() == yInterval.maxValue() &&
!( yInterval.borderFlags() & QwtInterval::ExcludeMaximum ) )
{
imageArea.adjust(0, 0, 0, pixelRect.height() );
}
QSize imageSize;
imageSize.setWidth( qRound( imageArea.width() / pixelRect.width() ) );
imageSize.setHeight( qRound( imageArea.height() / pixelRect.height() ) );
image = compose(xxMap, yyMap,
imageArea, paintRect, imageSize, doCache );
if ( image.isNull() )
return;
imageRect = qwtStripRect(paintRect, area,
xxMap, yyMap, xInterval, yInterval);
if ( ( image.width() > 1 || image.height() > 1 ) &&
testPaintAttribute( PaintInDeviceResolution ) )
{
// Because of rounding errors the pixels
// need to be expanded manually to rectangles of
// different sizes
image = qwtExpandImage(image, xxMap, yyMap,
imageArea, area, paintRect, xInterval, yInterval );
}
}
painter->save();
painter->setWorldTransform( QTransform() );
QwtPainter::drawImage( painter, imageRect, image );
painter->restore();
}
QRectF OverlayUser::scaledRect(const QRectF &qr, qreal scale) {
return QRectF(qr.x() * scale, qr.y() * scale, qr.width() * scale, qr.height() * scale);
}
void LinePlotCanvas::paint(QPainter *painter)
{
if (!updateTriggered())
return;
resetTrigger();
LinePlot *plot = qobject_cast<LinePlot*>(parent());
if (!plot) return;
Axis2DBase *monAxis = plot->axis2d();
NDArray &xArray = plot->xData(),
&yArray = plot->yData();
bool emptyX = (plot->xSize() == 0);
int N = (emptyX) ? plot->ySize() : qMin( plot->xSize(), plot->ySize() );
if (!monAxis || N == 0 || yArray.type() == NDArray::Unknown)
return; // Nothing to do
NDArrayTyped<qreal> yData = yArray.convert<qreal>();
QRectF lim = monAxis->limits();
// Get the transform params
QTransform tran = Util::plotToView(QSizeF(plot->width(), plot->height()), lim, monAxis->xAxis()->inverted(), monAxis->yAxis()->inverted());
qreal tx, ty, sx, sy, limx, limy;
Util::plotToView(plot->width(), plot->height(), lim, monAxis->xAxis()->inverted(), monAxis->yAxis()->inverted(),
tx, ty, sx, sy);
limx = lim.x();
limy = lim.y();
bool is_lines = (plot->line()->style() != ".");
if (is_lines && N < 2)
return; // Nothing to draw
// Allow the printer state to be restored
painter->save();
// painter->setTransform(QTransform());
preparePainter(painter, plot);
if (is_lines) {
QPainterPath path;
int starty = plot->startIndexY();
auto y = yData.begin() + starty;
if (emptyX) {
// Get the first point
int startx = 0;
qreal x = 0;
DRAW_LINES(x, *y);
} else {
auto xData = xArray.convert<qreal>();
// Get the first point
int startx = plot->startIndexX();
auto x = xData.begin() + startx;
DRAW_LINES(*x, *y);
}
// qDebug() << "Path:" << path;
painter->drawPath(path);
} else {
// Just drawing markers, therefore no need to "cut" lines, etc
qreal radius = painter->pen().widthF() * 0.5;
qreal px, py;
if (emptyX) {
int x = 0;
auto y = yData.begin();
DRAW_DOTS(x, *y);
} else {
auto xData = xArray.convert<qreal>();
auto x = xData.begin(), y = yData.begin();
DRAW_DOTS(*x, *y);
}
}
// Restore the painter to its former glory
painter->restore();
}
void OverlayUser::updateLayout() {
QPixmap pm;
if (scene())
uiSize = iroundf(scene()->sceneRect().height() + 0.5);
prepareGeometryChange();
for (int i=0;i<4;++i)
qgpiName[i]->setPixmap(pm);
qgpiAvatar->setPixmap(pm);
qgpiChannel->setPixmap(pm);
{
QImageReader qir(QLatin1String("skin:muted_self.svg"));
QSize sz = qir.size();
sz.scale(SCALESIZE(MutedDeafened), Qt::KeepAspectRatio);
qir.setScaledSize(sz);
qgpiMuted->setPixmap(QPixmap::fromImage(qir.read()));
}
{
QImageReader qir(QLatin1String("skin:deafened_self.svg"));
QSize sz = qir.size();
sz.scale(SCALESIZE(MutedDeafened), Qt::KeepAspectRatio);
qir.setScaledSize(sz);
qgpiDeafened->setPixmap(QPixmap::fromImage(qir.read()));
}
qgpiMuted->setPos(alignedPosition(scaledRect(os->qrfMutedDeafened, uiSize * os->fZoom), qgpiMuted->boundingRect(), os->qaMutedDeafened));
qgpiMuted->setZValue(1.0f);
qgpiMuted->setOpacity(os->fMutedDeafened);
qgpiDeafened->setPos(alignedPosition(scaledRect(os->qrfMutedDeafened, uiSize * os->fZoom), qgpiDeafened->boundingRect(), os->qaMutedDeafened));
qgpiDeafened->setZValue(1.0f);
qgpiDeafened->setOpacity(os->fMutedDeafened);
qgpiAvatar->setPos(0.0f, 0.0f);
qgpiAvatar->setOpacity(os->fAvatar);
for (int i=0;i<4;++i) {
qgpiName[i]->setPos(0.0f, 0.0f);
qgpiName[i]->setZValue(2.0f);
qgpiName[i]->setOpacity(os->fUserName);
}
qgpiChannel->setPos(0.0f, 0.0f);
qgpiChannel->setZValue(3.0f);
qgpiChannel->setOpacity(os->fChannel);
QRectF childrenBounds = os->qrfAvatar | os->qrfChannel | os->qrfMutedDeafened | os->qrfUserName;
bool haspen = (os->qcBoxPen != os->qcBoxFill) && (! qFuzzyCompare(os->qcBoxPen.alphaF(), static_cast<qreal>(0.0f)));
qreal pw = haspen ? qMax<qreal>(1.0f, os->fBoxPenWidth * uiSize * os->fZoom) : 0.0f;
qreal pad = os->fBoxPad * uiSize * os->fZoom;
QPainterPath pp;
pp.addRoundedRect(childrenBounds.x() * uiSize * os->fZoom + -pw / 2.0f - pad, childrenBounds.y() * uiSize * os->fZoom + -pw / 2.0f - pad, childrenBounds.width() * uiSize * os->fZoom + pw + 2.0f * pad, childrenBounds.height() * uiSize * os->fZoom + pw + 2.0f * pad, 2.0f * pw, 2.0f * pw);
qgpiBox->setPath(pp);
qgpiBox->setPos(0.0f, 0.0f);
qgpiBox->setZValue(-1.0f);
qgpiBox->setPen(haspen ? QPen(os->qcBoxPen, pw) : Qt::NoPen);
qgpiBox->setBrush(qFuzzyCompare(os->qcBoxFill.alphaF(), static_cast<qreal>(0.0f)) ? Qt::NoBrush : os->qcBoxFill);
qgpiBox->setOpacity(1.0f);
if (! cuUser) {
switch (tsColor) {
case Settings::Passive:
qsName = Overlay::tr("Silent");
break;
case Settings::Talking:
qsName = Overlay::tr("Talking");
break;
case Settings::Whispering:
qsName = Overlay::tr("Whisper");
break;
case Settings::Shouting:
qsName = Overlay::tr("Shout");
break;
}
}
}
void Clock::setViewRect(const QRectF &rect)
{
if (clock)
clock->setPos(rect.x(), rect.y());
}
void PlexyDayController::setViewRect(const QRectF &rect) {
if (mWidget) {
mWidget->setPos(rect.x(), rect.y());
}
}