int QLineEditPrivate::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const
{
QRect cr = adjustedContentsRect();
x-= cr.x() - hscroll + horizontalMargin;
return control->xToPos(x, betweenOrOn);
}
void toString(const QRect & rValue, QString & szBuffer)
{
szBuffer.sprintf("%d,%d,%d,%d", rValue.x(), rValue.y(), rValue.width(), rValue.height());
}
void BorderLayout::setGeometry(const QRect &rect)
{
ItemWrapper *center = 0;
int eastWidth = 0;
int westWidth = 0;
int northHeight = 0;
int southHeight = 0;
int centerHeight = 0;
int i;
QLayout::setGeometry(rect);
for (i = 0; i < list.size(); ++i) {
ItemWrapper *wrapper = list.at(i);
QLayoutItem *item = wrapper->item;
Position position = wrapper->position;
if (position == North) {
item->setGeometry(QRect(rect.x(), northHeight, rect.width(),
item->sizeHint().height()));
northHeight += item->geometry().height() + spacing();
} else if (position == South) {
item->setGeometry(QRect(item->geometry().x(),
item->geometry().y(), rect.width(),
item->sizeHint().height()));
southHeight += item->geometry().height() + spacing();
item->setGeometry(QRect(rect.x(),
rect.y() + rect.height() - southHeight + spacing(),
item->geometry().width(),
item->geometry().height()));
} else if (position == Center) {
center = wrapper;
}
}
centerHeight = rect.height() - northHeight - southHeight;
for (i = 0; i < list.size(); ++i) {
ItemWrapper *wrapper = list.at(i);
QLayoutItem *item = wrapper->item;
Position position = wrapper->position;
if (position == West) {
item->setGeometry(QRect(rect.x() + westWidth, northHeight,
item->sizeHint().width(), centerHeight));
westWidth += item->geometry().width() + spacing();
} else if (position == East) {
item->setGeometry(QRect(item->geometry().x(), item->geometry().y(),
item->sizeHint().width(), centerHeight));
eastWidth += item->geometry().width() + spacing();
item->setGeometry(QRect(
rect.x() + rect.width() - eastWidth + spacing(),
northHeight, item->geometry().width(),
item->geometry().height()));
}
}
if (center)
center->item->setGeometry(QRect(westWidth, northHeight,
rect.width() - eastWidth - westWidth,
centerHeight));
}
void IsometricRenderer::drawTileLayer(QPainter *painter,
const TileLayer *layer,
const QRectF &exposed) const
{
const int tileWidth = map()->tileWidth();
const int tileHeight = map()->tileHeight();
if (tileWidth <= 0 || tileHeight <= 1)
return;
QRect rect = exposed.toAlignedRect();
if (rect.isNull())
rect = boundingRect(layer->bounds());
QMargins drawMargins = layer->drawMargins();
drawMargins.setTop(drawMargins.top() - tileHeight);
drawMargins.setRight(drawMargins.right() - tileWidth);
rect.adjust(-drawMargins.right(),
-drawMargins.bottom(),
drawMargins.left(),
drawMargins.top());
// Determine the tile and pixel coordinates to start at
QPointF tilePos = pixelToTileCoords(rect.x(), rect.y());
QPoint rowItr = QPoint((int) std::floor(tilePos.x()),
(int) std::floor(tilePos.y()));
QPointF startPos = tileToPixelCoords(rowItr);
startPos.rx() -= tileWidth / 2;
startPos.ry() += tileHeight;
// Compensate for the layer position
rowItr -= QPoint(layer->x(), layer->y());
/* Determine in which half of the tile the top-left corner of the area we
* need to draw is. If we're in the upper half, we need to start one row
* up due to those tiles being visible as well. How we go up one row
* depends on whether we're in the left or right half of the tile.
*/
const bool inUpperHalf = startPos.y() - rect.y() > tileHeight / 2;
const bool inLeftHalf = rect.x() - startPos.x() < tileWidth / 2;
if (inUpperHalf) {
if (inLeftHalf) {
--rowItr.rx();
startPos.rx() -= tileWidth / 2;
} else {
--rowItr.ry();
startPos.rx() += tileWidth / 2;
}
startPos.ry() -= tileHeight / 2;
}
// Determine whether the current row is shifted half a tile to the right
bool shifted = inUpperHalf ^ inLeftHalf;
CellRenderer renderer(painter);
for (int y = startPos.y(); y - tileHeight < rect.bottom();
y += tileHeight / 2)
{
QPoint columnItr = rowItr;
for (int x = startPos.x(); x < rect.right(); x += tileWidth) {
if (layer->contains(columnItr)) {
const Cell &cell = layer->cellAt(columnItr);
if (!cell.isEmpty()) {
renderer.render(cell, QPointF(x, y),
CellRenderer::BottomLeft);
}
}
// Advance to the next column
++columnItr.rx();
--columnItr.ry();
}
// Advance to the next row
if (!shifted) {
++rowItr.rx();
startPos.rx() += tileWidth / 2;
shifted = true;
} else {
++rowItr.ry();
startPos.rx() -= tileWidth / 2;
shifted = false;
}
}
}
void HexagonalRenderer::drawTileLayer(QPainter *painter,
const TileLayer *layer,
const QRectF &exposed) const
{
const RenderParams p(map());
QRect rect = exposed.toAlignedRect();
if (rect.isNull())
rect = boundingRect(layer->bounds());
QMargins drawMargins = layer->drawMargins();
drawMargins.setBottom(drawMargins.bottom() + p.tileHeight);
drawMargins.setRight(drawMargins.right() - p.tileWidth);
rect.adjust(-drawMargins.right(),
-drawMargins.bottom(),
drawMargins.left(),
drawMargins.top());
// Determine the tile and pixel coordinates to start at
QPoint startTile = screenToTileCoords(rect.topLeft()).toPoint();
// Compensate for the layer position
startTile -= layer->position();
QPoint startPos = tileToScreenCoords(startTile + layer->position()).toPoint();
/* Determine in which half of the tile the top-left corner of the area we
* need to draw is. If we're in the upper half, we need to start one row
* up due to those tiles being visible as well. How we go up one row
* depends on whether we're in the left or right half of the tile.
*/
const bool inUpperHalf = rect.y() - startPos.y() < p.sideOffsetY;
const bool inLeftHalf = rect.x() - startPos.x() < p.sideOffsetX;
if (inUpperHalf)
startTile.ry()--;
if (inLeftHalf)
startTile.rx()--;
CellRenderer renderer(painter);
if (p.staggerX) {
startTile.setX(qMax(-1, startTile.x()));
startTile.setY(qMax(-1, startTile.y()));
startPos = tileToScreenCoords(startTile + layer->position()).toPoint();
startPos.ry() += p.tileHeight;
bool staggeredRow = p.doStaggerX(startTile.x() + layer->x());
for (; startPos.y() < rect.bottom() && startTile.y() < layer->height();) {
QPoint rowTile = startTile;
QPoint rowPos = startPos;
for (; rowPos.x() < rect.right() && rowTile.x() < layer->width(); rowTile.rx() += 2) {
if (layer->contains(rowTile)) {
const Cell &cell = layer->cellAt(rowTile);
if (!cell.isEmpty())
renderer.render(cell, rowPos, QSizeF(0, 0), CellRenderer::BottomLeft);
}
rowPos.rx() += p.tileWidth + p.sideLengthX;
}
if (staggeredRow) {
startTile.rx() -= 1;
startTile.ry() += 1;
startPos.rx() -= p.columnWidth;
staggeredRow = false;
} else {
startTile.rx() += 1;
startPos.rx() += p.columnWidth;
staggeredRow = true;
}
startPos.ry() += p.rowHeight;
}
} else {
startTile.setX(qMax(0, startTile.x()));
startTile.setY(qMax(0, startTile.y()));
startPos = tileToScreenCoords(startTile + layer->position()).toPoint();
startPos.ry() += p.tileHeight;
// Odd row shifting is applied in the rendering loop, so un-apply it here
if (p.doStaggerY(startTile.y() + layer->y()))
startPos.rx() -= p.columnWidth;
for (; startPos.y() < rect.bottom() && startTile.y() < layer->height(); startTile.ry()++) {
QPoint rowTile = startTile;
QPoint rowPos = startPos;
if (p.doStaggerY(startTile.y() + layer->y()))
rowPos.rx() += p.columnWidth;
for (; rowPos.x() < rect.right() && rowTile.x() < layer->width(); rowTile.rx()++) {
const Cell &cell = layer->cellAt(rowTile);
if (!cell.isEmpty())
renderer.render(cell, rowPos, QSizeF(0, 0), CellRenderer::BottomLeft);
rowPos.rx() += p.tileWidth + p.sideLengthX;
}
startPos.ry() += p.rowHeight;
}
}
}
// Experimental, using a mockup from Nuno Pinheiro (new_slider_nuno)
void SvgHandler::paintCustomSlider( QPainter *p, QStyleOptionSlider *slider, qreal percentage, bool paintMoodbar )
{
int sliderHeight = slider->rect.height() - 6;
const bool inverse = ( slider->orientation == Qt::Vertical ) ? slider->upsideDown :
( (slider->direction == Qt::RightToLeft) != slider->upsideDown );
QRect knob = sliderKnobRect( slider->rect, percentage, inverse );
QPoint pt = slider->rect.topLeft() + QPoint( 0, 2 );
//debug() << "rel: " << knobRelPos << ", width: " << width << ", height:" << height << ", %: " << percentage;
//if we should paint moodbar, paint this as the bottom layer
bool moodbarPainted = false;
if ( paintMoodbar )
{
Meta::TrackPtr currentTrack = The::engineController()->currentTrack();
if ( currentTrack )
{
if( The::moodbarManager()->hasMoodbar( currentTrack ) )
{
QPixmap moodbar = The::moodbarManager()->getMoodbar( currentTrack, slider->rect.width() - sliderHeight, sliderHeight, inverse );
p->drawPixmap( pt, renderSvg( "moodbar_end_left", sliderHeight / 2, sliderHeight, "moodbar_end_left" ) );
pt.rx() += sliderHeight / 2;
p->drawPixmap( pt, moodbar );
pt.rx() += slider->rect.width() - sliderHeight;
p->drawPixmap( pt, renderSvg( "moodbar_end_right", sliderHeight / 2, sliderHeight, "moodbar_end_right" ) );
moodbarPainted = true;
}
}
}
if( !moodbarPainted )
{
// Draw the slider background in 3 parts
p->drawPixmap( pt, renderSvg( "progress_slider_left", sliderHeight, sliderHeight, "progress_slider_left" ) );
pt.rx() += sliderHeight;
QRect midRect(pt, QSize(slider->rect.width() - sliderHeight * 2, sliderHeight) );
p->drawTiledPixmap( midRect, renderSvg( "progress_slider_mid", 32, sliderHeight, "progress_slider_mid" ) );
pt = midRect.topRight() + QPoint( 1, 0 );
p->drawPixmap( pt, renderSvg( "progress_slider_right", sliderHeight, sliderHeight, "progress_slider_right" ) );
//draw the played background.
int playedBarHeight = sliderHeight - 6;
int sizeOfLeftPlayed = qBound( 0, inverse ? slider->rect.right() - knob.right() + 2 :
knob.x() - 2, playedBarHeight );
if( sizeOfLeftPlayed > 0 )
{
QPoint tl, br;
if ( inverse )
{
tl = knob.topRight() + QPoint( -5, 5 ); // 5px x padding to avoid a "gap" between it and the top and bottom of the round knob.
br = slider->rect.topRight() + QPoint( -3, 5 + playedBarHeight - 1 );
QPixmap rightEnd = renderSvg( "progress_slider_played_right", playedBarHeight, playedBarHeight, "progress_slider_played_right" );
p->drawPixmap( br.x() - rightEnd.width() + 1, tl.y(), rightEnd, qMax(0, rightEnd.width() - (sizeOfLeftPlayed + 3)), 0, sizeOfLeftPlayed + 3, playedBarHeight );
br.rx() -= playedBarHeight;
}
else
{
tl = slider->rect.topLeft() + QPoint( 3, 5 );
br = QPoint( knob.x() + 5, tl.y() + playedBarHeight - 1 );
QPixmap leftEnd = renderSvg( "progress_slider_played_left", playedBarHeight, playedBarHeight, "progress_slider_played_left" );
p->drawPixmap( tl.x(), tl.y(), leftEnd, 0, 0, sizeOfLeftPlayed + 3, playedBarHeight );
tl.rx() += playedBarHeight;
}
if ( sizeOfLeftPlayed == playedBarHeight )
p->drawTiledPixmap( QRect(tl, br), renderSvg( "progress_slider_played_mid", 32, playedBarHeight, "progress_slider_played_mid" ) );
}
}
if ( slider->state & QStyle::State_Enabled )
{ // Draw the knob (handle)
const char *string = ( slider->activeSubControls & QStyle::SC_SliderHandle ) ?
"slider_knob_200911_active" : "slider_knob_200911";
p->drawPixmap( knob.topLeft(), renderSvg( string, knob.width(), knob.height(), string ) );
}
}
static inline QRect toBottomLeftRect(const QRect &topLeftRect, int windowHeight)
{
return QRect(topLeftRect.x(), windowHeight - topLeftRect.bottomRight().y() - 1,
topLeftRect.width(), topLeftRect.height());
}
void DiagramCanvas::paint_all( QRect& r )
{
int i;
QPainter p( &buffer );
QPen pen;
QBrush brush;
QPointArray a;
QColor color;
QRegion mask, crossing_disk;
set<double>::iterator dbl_it;
for ( i=0; i<crossingList.size(); ++i )
{
Crossing *c = crossingList[i];
c->under->underpasses.insert( c->under->underpasses.end(), c->position_on_understrand );
}
for ( i=0; i<edgeList.size(); ++i )
{
Edge *e = edgeList[i];
pen.setWidth( e->thickness );
pen.setColor( CANVAS );
p.setPen( pen );
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
}
for ( i=0; i<edgeList.size(); ++i )
{
Edge *e = edgeList[i];
color = (e->edge_type == drilled) ? DRILLED : colorList[e->arc_id % 18 ];
pen.setWidth( e->thickness );
pen.setColor( color );
p.setPen( pen );
brush.setColor( color );
brush.setStyle( SolidPattern );
p.setBrush( brush );
if ( e->underpasses.size() > 0 )
{
p.setClipping( TRUE );
mask = QRegion( 0, 0, width(), height(), QRegion::Rectangle );
for ( dbl_it=e->underpasses.begin(); dbl_it!=e->underpasses.end(); ++dbl_it )
{
QPoint center = time_to_point( e, *dbl_it );
crossing_disk = QRegion( center.x()-7, center.y()-7, 14, 14 , QRegion::Ellipse );
mask -= crossing_disk;
}
p.setClipRegion( mask );
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
p.setClipping( FALSE );
}
else
{
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
}
e->underpasses.clear();
}
p.end();
bitBlt( this, r.x(), r.y(), &buffer, r.x(), r.y(), r.width(), r.height() );
}
void FileView::paint(QPainter* painter, const QRect& rect, const QPalette& palette, DisplayMode displayMode) const {
painter->save();
painter->setRenderHint(QPainter::Antialiasing, true);
painter->translate(rect.x(), rect.y());
if(displayMode == DM_Selected)
painter->setBrush(palette.highlightedText());
else
painter->setBrush(palette.foreground());
painter->setPen(QPen(painter->brush(), 1));
int textFlags = Qt::AlignLeft | Qt::AlignVCenter;
QFont font(painter->font());
font.setBold(true);
painter->setFont(font);
QString nameDisplay = (mode == TM_Send) ? tr("To: ") : tr("From: ");
nameDisplay.append(userName);
QRect textRect = QRect(54, 0, rect.width() - 58, 18);
QString text = painter->fontMetrics().elidedText(nameDisplay, Qt::ElideRight, textRect.width());
painter->drawText(textRect, textFlags, text);
font.setBold(false);
painter->setFont(font);
textRect = QRect(54, 18, rect.width() - 58, 18);
text = painter->fontMetrics().elidedText(fileDisplay, Qt::ElideMiddle, textRect.width());
painter->drawText(textRect, textFlags, text);
bool drawProgress = false;
QString stateDisplay;
switch(state) {
case TS_Send:
stateDisplay = timeDisplay + " left - " + posDisplay + " of " + sizeDisplay + " (" + speedDisplay + ")";
drawProgress = true;
break;
case TS_Receive:
stateDisplay = timeDisplay + " left - " + posDisplay + " of " + sizeDisplay + " (" + speedDisplay + ")";
drawProgress = true;
break;
case TS_Complete:
stateDisplay = tr("Completed");
break;
case TS_Cancel:
stateDisplay = tr("Canceled");
break;
case TS_Abort:
stateDisplay = tr("Interrupted");
break;
default:
break;
}
textRect = QRect(54, 36, rect.width() - 58, 18);
text = painter->fontMetrics().elidedText(stateDisplay, Qt::ElideRight, textRect.width());
painter->drawText(textRect, textFlags, text);
if(drawProgress) {
int spanAngle = ((double)position / (double)fileSize) * 360;
painter->setBrush(QBrush(QColor(230, 230, 230)));
painter->setPen(QPen(QColor(230, 230, 230)));
painter->drawPie(4, 4, 46, 46, (90 - spanAngle) * 16, -(360 - spanAngle) * 16);
painter->setBrush(QBrush(QColor(150, 225, 110)));
painter->setPen(QPen(QColor(150, 225, 110)));
painter->drawPie(4, 4, 46, 46, 90 * 16, -spanAngle * 16);
painter->setBrush(QBrush(QColor(255, 255, 255)));
painter->setPen(QPen(QColor(255, 255, 255), 2));
painter->drawLine(27, 5, 27, 49);
painter->drawLine(5, 27, 49, 27);
painter->drawLine(11, 11, 42, 42);
painter->drawLine(42, 11, 11, 42);
}
QRect imageRect(11, 11, 32, 32);
painter->drawPixmap(imageRect, icon);
painter->restore();
}
// Read and write rectangle in X11 resource syntax "12x12+4+3"
static QString rectangleToString(const QRect &r)
{
QString result;
QTextStream(&result) << r.width() << 'x' << r.height() << forcesign << r.x() << r.y();
return result;
}
void
PartitionBarsView::drawSection( QPainter* painter, const QRect& rect_, int x, int width, const QModelIndex& index )
{
QColor color = index.isValid() ?
index.data( Qt::DecorationRole ).value< QColor >() :
ColorUtils::unknownDisklabelColor();
bool isFreeSpace = index.isValid() ?
index.data( PartitionModel::IsFreeSpaceRole ).toBool() :
true;
QRect rect = rect_;
const int y = rect.y();
const int height = rect.height();
const int radius = qMax( 1, CORNER_RADIUS - ( VIEW_HEIGHT - height ) / 2 );
painter->setClipRect( x, y, width, height );
painter->translate( 0.5, 0.5 );
rect.adjust( 0, 0, -1, -1 );
if ( selectionMode() != QAbstractItemView::NoSelection && // no hover without selection
m_hoveredIndex.isValid() &&
index == m_hoveredIndex )
{
if ( canBeSelected( index ) )
painter->setBrush( color.lighter( 115 ) );
else
painter->setBrush( color );
}
else
{
painter->setBrush( color );
}
QColor borderColor = color.darker();
painter->setPen( borderColor );
painter->drawRoundedRect( rect, radius, radius );
// Draw shade
if ( !isFreeSpace )
rect.adjust( 2, 2, -2, -2 );
QLinearGradient gradient( 0, 0, 0, height / 2 );
qreal c = isFreeSpace ? 0 : 1;
gradient.setColorAt( 0, QColor::fromRgbF( c, c, c, 0.3 ) );
gradient.setColorAt( 1, QColor::fromRgbF( c, c, c, 0 ) );
painter->setPen( Qt::NoPen );
painter->setBrush( gradient );
painter->drawRoundedRect( rect, radius, radius );
if ( selectionMode() != QAbstractItemView::NoSelection &&
index.isValid() &&
selectionModel() &&
!selectionModel()->selectedIndexes().isEmpty() &&
selectionModel()->selectedIndexes().first() == index )
{
painter->setPen( QPen( borderColor, 1 ) );
QColor highlightColor = QPalette().highlight().color();
highlightColor = highlightColor.lighter( 500 );
highlightColor.setAlpha( 120 );
painter->setBrush( highlightColor );
QRect selectionRect = rect;
selectionRect.setX( x + 1 );
selectionRect.setWidth( width - 3 ); //account for the previous rect.adjust
if ( rect.x() > selectionRect.x() ) //hack for first item
selectionRect.adjust( rect.x() - selectionRect.x(), 0, 0, 0 );
if ( rect.right() < selectionRect.right() ) //hack for last item
selectionRect.adjust( 0, 0, - ( selectionRect.right() - rect.right() ), 0 );
selectionRect.adjust( SELECTION_MARGIN,
SELECTION_MARGIN,
-SELECTION_MARGIN,
-SELECTION_MARGIN );
painter->drawRoundedRect( selectionRect,
radius - 1,
radius - 1 );
}
painter->translate( -0.5, -0.5 );
}
void PseudoStateCanvas::draw(QPainter & p) {
if (!visible() || ((xpm == 0) && !manual_size)) return;
QRect r = rect();
QRect intern_r;
p.setBackgroundMode(::Qt::OpaqueMode);
if (xpm != 0)
p.drawPixmap(r.topLeft(), *xpm);
else {
// jork join manually sized
if (horiz) {
intern_r.setX(r.x() + 1);
intern_r.setWidth(r.width() - 2);
intern_r.setY(r.y() + 6);
intern_r.setHeight(3);
}
else {
intern_r.setX(r.x() + 6);
intern_r.setWidth(3);
intern_r.setY(r.y() + 1);
intern_r.setHeight(r.height() - 2);
}
p.fillRect(intern_r, ::Qt::black);
}
if (selected())
show_mark(p, r);
FILE * fp = svg();
if (fp != 0) {
bool big = the_canvas()->zoom() >= 1.0;
int px = (int) x();
int py = (int) y();
switch (browser_node->get_type()) {
case InitialPS:
if (big)
fprintf(fp, "<ellipse fill=\"black\" cx=\"%d\" cy=\"%d\" rx=\"8.5\" ry=\"8.5\" />\n",
px + 9, py + 9);
else
fprintf(fp, "<ellipse fill=\"black\" cx=\"%d\" cy=\"%d\" rx=\"5.5\" ry=\"5.5\" />\n",
px + 7, py + 7);
break;
case EntryPointPS:
if (big)
fprintf(fp, "<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"8.5\" ry=\"8.5\" />\n",
px + 9, py + 9);
else
fprintf(fp, "<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"5.5\" ry=\"5.5\" />\n",
px + 7, py + 7);
break;
case FinalPS:
if (big) {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"11.5\" ry=\"11.5\" />\n",
px + 12, py + 12);
fprintf(fp, "\t<ellipse fill=\"black\" cx=\"%d\" cy=\"%d\" rx=\"8.5\" ry=\"8.5\" />\n"
"</g>\n",
px + 12, py + 12);
}
else {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"7.5\" ry=\"7.5\" />\n",
px + 8, py + 8);
fprintf(fp, "\t<ellipse fill=\"black\" cx=\"%d\" cy=\"%d\" rx=\"4.5\" ry=\"4.5\" />\n"
"</g>\n",
px + 8, py + 8);
}
break;
case TerminatePS:
if (big) {
fprintf(fp, "<g>\n"
"\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 1, py + 1, px + 19, py + 19);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 19, py + 1, px + 1, py + 19);
}
else{
fprintf(fp, "<g>\n"
"\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 2, py + 2, px + 12, py + 12);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 12, py + 2, px + 2, py + 12);
}
break;
case ExitPointPS:
if (big) {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"8.5\" ry=\"8.5\" />\n",
px + 9, py + 9);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 4, px + 14, py + 14);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 14, py + 4, px + 4, py + 14);
}
else {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"5.5\" ry=\"5.5\" />\n",
px + 7, py + 7);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 4, px + 10, py + 10);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 10, py + 4, px + 4, py + 10);
}
break;
case DeepHistoryPS:
if (big) {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"12.5\" ry=\"12.5\" />\n",
px + 12, py + 12);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 8, px + 4, py + 16);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 10, py + 8, px + 10, py + 16);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 12, px + 10, py + 12);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 12, py + 9, px + 20, py + 9);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 13, py + 6, px + 19, py + 12);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 13, py + 12, px + 19, py + 6);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 16, py + 5, px + 16, py + 13);
}
else {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"7.5\" ry=\"7.5\" />\n",
px + 8, py + 8);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 6, px + 4, py + 10);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 7, py + 6, px + 7, py + 10);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 4, py + 8, px + 7, py + 8);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 9, py + 7, px + 13, py + 7);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 9, py + 5, px + 13, py + 9);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 9, py + 9, px + 13, py + 5);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 11, py + 5, px + 11, py + 9);
}
break;
case ShallowHistoryPS:
if (big) {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"12.5\" ry=\"12.5\" />\n",
px + 12, py + 12);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 8, py + 8, px + 8, py + 16);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 15, py + 8, px + 15, py + 16);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 8, py + 12, px + 15, py + 12);
}
else {
fprintf(fp, "<g>\n"
"\t<ellipse fill=\"white\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" cx=\"%d\" cy=\"%d\" rx=\"7.5\" ry=\"7.5\" />\n",
px + 8, py + 8);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 5, py + 5, px + 5, py + 11);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 11, py + 5, px + 11, py + 11);
fprintf(fp, "\t<line stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
"</g>\n",
px + 5, py + 8, px + 11, py + 8);
}
break;
case JunctionPS:
if (big)
fprintf(fp, "<ellipse fill=\"black\" stroke=\"none\" cx=\"%d\" cy=\"%d\" rx=\"6.5\" ry=\"6.5\" />\n",
px + 7, py + 7);
else
fprintf(fp, "<ellipse fill=\"black\" stroke=\"none\" cx=\"%d\" cy=\"%d\" rx=\"4.5\" ry=\"4.5\" />\n",
px + 5, py + 5);
break;
case ChoicePS:
// note : shadow not produced
if (big)
fprintf(fp, "<polygon fill=\"white\" stroke=\"black\" stroke-opacity=\"1\" points =\"%d,%d %d,%d %d,%d %d,%d\" />\n",
px + 3, py + 18, px + 12, py + 1, px + 21, py + 18, px + 12, py + 35);
else
fprintf(fp, "<polygon fill=\"white\" stroke=\"black\" stroke-opacity=\"1\" points =\"%d,%d %d,%d %d,%d %d,%d\" />\n",
px + 2, py + 12, px + 8, py + 1, px + 14, py + 12, px + 8, py + 23);
break;
case ForkPS:
case JoinPS:
if (horiz) {
if (manual_size)
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
intern_r.x(), intern_r.y(), intern_r.x() + intern_r.width() - 1, intern_r.y());
else if (big)
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 1, py + 6, px + 23, py + 6);
else
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 1, py + 6, px + 16, py + 6);
}
else {
if (manual_size)
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
intern_r.x(), intern_r.y(), intern_r.x(), intern_r.y() + intern_r.height() - 1);
else if (big)
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 6, py + 1, px + 6, py + 24);
else
fprintf(fp, "<line stroke=\"black\" stroke-width=\"3\" stroke-opacity=\"1\" x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
px + 6, py + 1, px + 6, py + 17);
}
break;
default:
break;
}
}
}
void QRoundedRect::compile(QSqlDatabase &db, int nSceneId,int &count,int index)
{
count++;
//QBasicGraphicsItem::compile(db, nSceneId, count, index);
QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO polygon(nItemId ,nSceneId,ePolygonClass,eLineType ,nLineWidth,nLineColor,"
"eStyle,nBackColor,nForeColor,nAlpha,nPointX,nPointY,nWidth,nHeight,nRadius,eCornerType,"
"nZvalue,nCollidindId)"
"VALUES (:nItemId,:nSceneId,:ePolygonClass ,:eLineType ,:nLineWidth,:nLineColor,:eStyle,"
":nBackColor,:nForeColor,:nAlpha,:nPointX,:nPointY,:nWidth,:nHeight,:nRadius,:eCornerType,"
":nZvalue,:nCollidindId)");
sqlquery.bindValue(":nItemId",QVariant(count));// 表 id
sqlquery.bindValue(":nSceneId",QVariant(nSceneId));// 所在场景 id
sqlquery.bindValue(":ePolygonClass",QVariant(4)); //4 代表类型为圆角矩形
sqlquery.bindValue(":eLineType",QVariant(nLineType+1));// 线形
sqlquery.bindValue(":nLineWidth",QVariant(GetLineWidth()));// 线宽
sqlquery.bindValue(":nLineColor",QVariant(ColorToInt(GetLineColor()))); //颜色
sqlquery.bindValue(":eStyle",QVariant(GetPattern()+1));// 样式
sqlquery.bindValue(":nBackColor",QVariant(ColorToInt(GetBackColor()))); //背景色
sqlquery.bindValue(":nForeColor",QVariant(ColorToInt(GetFrontColor()))); //前景色
sqlquery.bindValue(":nAlpha",QVariant(GetAlpha()));// 透明度
QRect rect = this->sceneBoundingRect().toRect();
sqlquery.bindValue(":nStartX",QVariant(rect.x()));//x
sqlquery.bindValue(":nStartY",QVariant(rect.y()));//y
sqlquery.bindValue(":nWidth",QVariant(rect.width()));//w
sqlquery.bindValue(":nHeight",QVariant(rect.height()));//h
sqlquery.bindValue(":nRadius",QVariant(GetxRadius())); //
sqlquery.bindValue(":eCornerType",QVariant(GetyRadius())); //
sqlquery.bindValue(":nZvalue",QVariant(zValue()));//层次
sqlquery.bindValue(":nCollidindId",QVariant(index));//碰撞ID
bool result = false;
result = sqlquery.exec();
qDebug() << "insert RoundedRect table :"<<result;
SamDrawScene *pScene = dynamic_cast<SamDrawScene *>(scene());
if(pScene && pScene->nIsSceneOrWindow == 2)
{
//是自定义键盘的item
//先新建键盘——item关联表 item表在派生类中创建
//QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO kbAndItem(nKeyBoardId , nItemId ,nId,nItemTableType ) "
"VALUES (:nKeyBoardId ,:nItemId ,:nId,:nItemTableType)");
sqlquery.bindValue(":nKeyBoardId",QVariant(nSceneId));
sqlquery.bindValue(":nItemId",QVariant(count));
sqlquery.bindValue(":nId",QVariant(id()));
sqlquery.bindValue(":nItemTableType",QVariant((int)SAM_DRAW_OBJECT_ROUNDEDRECT));
bool result = false;
result = sqlquery.exec();
qDebug() << "insert kbAndItem table :"<<result;
}
if(pScene && pScene->nIsSceneOrWindow != 2)
{
//窗口或者场景item
//先新建键盘——item关联表
//item表在派生类中创建
//QSqlQuery sqlquery(db);
sqlquery.prepare("INSERT INTO sceneAndItem(nSceneId,nItemId,nId,nItemTableType)"
"VALUES(:nSceneId,:nItemId,:nId,:nItemTableType)");
sqlquery.bindValue(":nSceneId",QVariant(nSceneId));
sqlquery.bindValue(":nItemId",QVariant(count));
sqlquery.bindValue(":nId",QVariant(id()));
//int t = this->GroupType();
sqlquery.bindValue(":nItemTableType",QVariant((int)SAM_DRAW_OBJECT_ROUNDEDRECT));
bool result = false;
result = sqlquery.exec();
qDebug() << "insert sceneAndItem table :"<<result;
}
}
void UberDelegate::paint_skill(const QRect &adjusted, int rating, QColor bg, QPainter *p, const QStyleOptionViewItem &opt, const QModelIndex &) const {
QColor c = color_skill;
if (auto_contrast)
c = compliment(bg);
p->save();
switch(m_skill_drawing_method) {
default:
case SDM_GROWING_CENTRAL_BOX:
if (rating >= 15) {
// draw diamond
p->setRenderHint(QPainter::Antialiasing);
p->setPen(Qt::gray);
p->setBrush(QBrush(c));
p->translate(opt.rect.x() + 2, opt.rect.y() + 2);
p->scale(opt.rect.width()-4, opt.rect.height()-4);
p->drawPolygon(m_diamond_shape);
} else if (rating > -1 && rating < 15) {
float size = 0.75f * ((rating + 1) / 15.0f); // even dabbling (0) should be drawn
float inset = (1.0f - size) / 2.0f;
p->translate(adjusted.x(), adjusted.y());
p->scale(adjusted.width(), adjusted.height());
p->fillRect(QRectF(inset, inset, size, size), QBrush(c));
}
break;
case SDM_GROWING_FILL:
if (rating >= 15) {
// draw diamond
p->setRenderHint(QPainter::Antialiasing);
p->setPen(Qt::gray);
p->setBrush(QBrush(c));
p->translate(opt.rect.x() + 2, opt.rect.y() + 2);
p->scale(opt.rect.width() - 4, opt.rect.height() - 4);
p->drawPolygon(m_diamond_shape);
} else if (rating > -1 && rating < 15) {
float size = (rating + 2) / 16.0f;
p->translate(adjusted.x(), adjusted.y());
p->scale(adjusted.width(), adjusted.height());
p->fillRect(QRectF(0, 0, size, 1), QBrush(c));
}
break;
case SDM_GLYPH_LINES:
{
p->setBrush(QBrush(c));
p->setPen(c);
p->translate(adjusted.x(), adjusted.y());
p->scale(adjusted.width(), adjusted.height());
QVector<QLineF> lines;
switch (rating) {
case 20:
case 19:
case 18:
case 17:
case 16:
case 15:
{
p->resetTransform();
p->translate(adjusted.x() + adjusted.width()/2.0,
adjusted.y() + adjusted.height()/2.0);
p->scale(adjusted.width(), adjusted.height());
p->rotate(-18);
p->setRenderHint(QPainter::Antialiasing);
p->drawPolygon(m_star_shape, Qt::WindingFill);
}
break;
case 14:
{
QPolygonF poly;
poly << QPointF(0.5, 0.1)
<< QPointF(0.5, 0.5)
<< QPointF(0.9, 0.5);
p->drawPolygon(poly);
}
case 13:
{
QPolygonF poly;
poly << QPointF(0.1, 0.5)
<< QPointF(0.5, 0.5)
<< QPointF(0.5, 0.9);
p->drawPolygon(poly);
}
case 12:
{
QPolygonF poly;
poly << QPointF(0.9, 0.5)
<< QPointF(0.5, 0.5)
<< QPointF(0.5, 0.9);
p->drawPolygon(poly);
}
case 11:
{
QPolygonF poly;
poly << QPointF(0.1, 0.5)
<< QPointF(0.5, 0.5)
<< QPointF(0.5, 0.1);
p->drawPolygon(poly);
}
case 10: // accomplished
lines << QLineF(QPointF(0.5, 0.1), QPointF(0.9, 0.5));
case 9: //professional
lines << QLineF(QPointF(0.1, 0.5), QPointF(0.5, 0.1));
case 8: //expert
lines << QLineF(QPointF(0.5, 0.9), QPointF(0.1, 0.5));
case 7: //adept
lines << QLineF(QPointF(0.5, 0.9), QPointF(0.9, 0.5));
case 6: //talented
lines << QLineF(QPointF(0.5, 0.5), QPointF(0.5, 0.9));
case 5: //proficient
lines << QLineF(QPointF(0.5, 0.5), QPointF(0.9, 0.5));
case 4: //skilled
lines << QLineF(QPointF(0.5, 0.1), QPointF(0.5, 0.5));
case 3: //competent
lines << QLineF(QPointF(0.1, 0.5), QPointF(0.5, 0.5));
case 2: //untitled
lines << QLineF(QPointF(0.7, 0.3), QPointF(0.3, 0.7));
case 1: //novice
lines << QLineF(QPointF(0.3, 0.3), QPointF(0.7, 0.7));
case 0: //dabbling
lines << QLineF(QPointF(0.5, 0.5), QPointF(0.5, 0.5));
break;
}
p->drawLines(lines);
}
break;
case SDM_NUMERIC:
if (rating > -1) { // don't draw 0s everywhere
p->setPen(c);
p->drawText(opt.rect, Qt::AlignCenter, QString::number(rating));
}
break;
}
p->restore();
}
void ArthurStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
QPainter *painter, const QWidget *widget) const
{
switch (control) {
case CC_Slider:
if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
QRect groove = subControlRect(CC_Slider, option, SC_SliderGroove, widget);
QRect handle = subControlRect(CC_Slider, option, SC_SliderHandle, widget);
painter->save();
bool hover = (slider->state & State_Enabled) && (slider->state & State_MouseOver);
if (hover) {
QRect moderated = widget->rect().adjusted(0, 4, 0, -4);
drawHoverRect(painter, moderated);
}
if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
QPixmap grv = cached(":res/images/slider_bar.png");
painter->drawPixmap(QRect(groove.x() + 5, groove.y(),
groove.width() - 10, grv.height()),
grv);
}
if ((option->subControls & SC_SliderHandle) && handle.isValid()) {
QPixmap hndl = cached(":res/images/slider_thumb_on.png");
painter->drawPixmap(handle.topLeft(), hndl);
}
painter->restore();
}
break;
case CC_GroupBox:
if (const QStyleOptionGroupBox *groupBox
= qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {
QStyleOptionGroupBox groupBoxCopy(*groupBox);
groupBoxCopy.subControls &= ~SC_GroupBoxLabel;
QWindowsStyle::drawComplexControl(control, &groupBoxCopy, painter, widget);
if (groupBox->subControls & SC_GroupBoxLabel) {
const QRect &r = groupBox->rect;
QPixmap titleLeft = cached(":res/images/title_cap_left.png");
QPixmap titleRight = cached(":res/images/title_cap_right.png");
QPixmap titleStretch = cached(":res/images/title_stretch.png");
int txt_width = groupBox->fontMetrics.width(groupBox->text) + 20;
painter->drawPixmap(r.center().x() - txt_width/2, 0, titleLeft);
QRect tileRect = subControlRect(control, groupBox, SC_GroupBoxLabel, widget);
painter->drawTiledPixmap(tileRect, titleStretch);
painter->drawPixmap(tileRect.x() + tileRect.width(), 0, titleRight);
int opacity = 31;
painter->setPen(QColor(0, 0, 0, opacity));
painter->drawText(tileRect.translated(0, 1),
Qt::AlignVCenter | Qt::AlignHCenter, groupBox->text);
painter->drawText(tileRect.translated(2, 1),
Qt::AlignVCenter | Qt::AlignHCenter, groupBox->text);
painter->setPen(QColor(0, 0, 0, opacity * 2));
painter->drawText(tileRect.translated(1, 1),
Qt::AlignVCenter | Qt::AlignHCenter, groupBox->text);
painter->setPen(Qt::white);
painter->drawText(tileRect, Qt::AlignVCenter | Qt::AlignHCenter, groupBox->text);
}
}
break;
default:
QWindowsStyle::drawComplexControl(control, option, painter, widget);
break;
}
return;
}
void QScriptEdit::extraAreaPaintEvent(QPaintEvent *e)
{
QRect rect = e->rect();
QPalette pal = palette();
pal.setCurrentColorGroup(QPalette::Active);
QPainter painter(m_extraArea);
painter.fillRect(rect, Qt::lightGray);
const QFontMetrics fm(fontMetrics());
int markWidth = fm.lineSpacing();
int extraAreaWidth = m_extraArea->width();
QLinearGradient gradient(QPointF(extraAreaWidth - 10, 0), QPointF(extraAreaWidth, 0));
gradient.setColorAt(0, pal.color(QPalette::Background));
gradient.setColorAt(1, pal.color(QPalette::Base));
painter.fillRect(rect, gradient);
QLinearGradient gradient2(QPointF(0, 0), QPointF(markWidth, 0));
gradient2.setColorAt(0, pal.color(QPalette::Dark));
gradient2.setColorAt(1, pal.color(QPalette::Background));
painter.fillRect(rect.intersected(QRect(rect.x(), rect.y(), markWidth, rect.height())), gradient2);
painter.setPen(QPen(pal.color(QPalette::Background), 2));
if (isLeftToRight())
painter.drawLine(rect.x() + extraAreaWidth-1, rect.top(), rect.x() + extraAreaWidth-1, rect.bottom());
else
painter.drawLine(rect.x(), rect.top(), rect.x(), rect.bottom());
painter.setRenderHint(QPainter::Antialiasing);
#ifndef QT_NO_SYNTAXHIGHLIGHTER
QTextBlock block = firstVisibleBlock();
int blockNumber = block.blockNumber();
qreal top = blockBoundingGeometry(block).translated(contentOffset()).top();
qreal bottom = top + blockBoundingRect(block).height();
QString imagesPath = QString::fromLatin1(":/qt/scripttools/debugging/images");
QString imageExt;
// SVGs don't work on all platforms, even when QT_NO_SVG is not defined, so disable SVG usage for now.
// #ifndef QT_NO_SVG
#if 0
imageExt = QString::fromLatin1("svg");
#else
imageExt = QString::fromLatin1("png");
#endif
while (block.isValid() && top <= rect.bottom()) {
if (block.isVisible() && bottom >= rect.top()) {
int lineNumber = blockNumber + m_baseLineNumber;
if (m_breakpoints.contains(lineNumber)) {
int radius = fm.lineSpacing() - 1;
QRect r(rect.x(), (int)top, radius, radius);
QIcon icon(m_breakpoints[lineNumber].enabled
? QString::fromLatin1("%0/breakpoint.%1").arg(imagesPath).arg(imageExt)
: QString::fromLatin1("%0/d_breakpoint.%1").arg(imagesPath).arg(imageExt));
icon.paint(&painter, r, Qt::AlignCenter);
}
if (m_executionLineNumber == lineNumber) {
int radius = fm.lineSpacing() - 1;
QRect r(rect.x(), (int)top, radius, radius);
QIcon icon(QString::fromLatin1("%0/location.%1").arg(imagesPath).arg(imageExt));
icon.paint(&painter, r, Qt::AlignCenter);
}
if (!isExecutableLine(lineNumber))
painter.setPen(pal.color(QPalette::Mid));
else
painter.setPen(QColor(Qt::darkCyan));
QString number = QString::number(lineNumber);
painter.drawText(rect.x() + markWidth, (int)top, rect.x() + extraAreaWidth - markWidth - 4,
fm.height(), Qt::AlignRight, number);
}
block = block.next();
top = bottom;
bottom = top + blockBoundingRect(block).height();
++blockNumber;
}
#endif
}
void PlayerSetupDialog::setCurrentPlayer(PlayerConnection* con)
{
if(con == m_con)
return;
m_stickyConnectionMessage = false;
if(m_con)
{
disconnect(ui->playerName, 0, m_con, 0);
disconnect(ui->playerHost, 0, m_con, 0);
disconnect(ui->playerUser, 0, m_con, 0);
disconnect(ui->playerPass, 0, m_con, 0);
disconnect(m_con, 0, this, 0);
}
if(m_subviewModel)
{
delete m_subviewModel;
m_subviewModel = 0;
}
m_con = con;
if(!con)
{
ui->boxConnection->setEnabled(false);
ui->boxOutput->setEnabled(false);
ui->boxSubviewOpts->setEnabled(false);
ui->boxSubviews->setEnabled(false);
ui->boxKeystone->setEnabled(true);
return;
}
if(con->isConnected())
conConnected();
else
conDisconnected();
// Set up the UI with values from the player before connecting slots so we dont needlessly update the object
ui->playerName->setText(con->name());
ui->playerHost->setText(con->host());
ui->playerUser->setText(con->user());
ui->playerPass->setText(con->pass());
ui->autoconnectBox->setChecked(con->autoconnect());
ui->optIgnoreAR->setChecked(con->aspectRatioMode() == Qt::IgnoreAspectRatio);
QRect screen = con->screenRect();
if(screen.isEmpty())
con->setScreenRect(screen = QRect(0,0,1024,768));
ui->outputX->setValue(screen.x());
ui->outputY->setValue(screen.y());
ui->outputWidth->setValue(screen.width());
ui->outputHeight->setValue(screen.height());
QRect view = con->viewportRect();
if(view.isEmpty())
con->setViewportRect(view = QRect(0,0,1000,750));
ui->viewportX->setValue(view.x());
ui->viewportY->setValue(view.y());
ui->viewportWidth->setValue(view.width());
ui->viewportHeight->setValue(view.height());
connect(ui->playerName, SIGNAL(textChanged(QString)), con, SLOT(setName(QString)));
connect(ui->playerHost, SIGNAL(textChanged(QString)), con, SLOT(setHost(QString)));
connect(ui->playerUser, SIGNAL(textChanged(QString)), con, SLOT(setUser(QString)));
connect(ui->playerPass, SIGNAL(textChanged(QString)), con, SLOT(setPass(QString)));
connect(con, SIGNAL(connected()), this, SLOT(conConnected()));
connect(con, SIGNAL(disconnected()), this, SLOT(conDisconnected()));
connect(con, SIGNAL(loginSuccess()), this, SLOT(conLoginSuccess()));
connect(con, SIGNAL(loginFailure()), this, SLOT(conLoginFailure()));
connect(con, SIGNAL(playerError(QString)), this, SLOT(conPlayerError(QString)));
connect(con, SIGNAL(pingResponseReceived(QString)), this, SLOT(conPingResponseReceived(QString)));
connect(con, SIGNAL(testStarted()), this, SLOT(conTestStarted()));
connect(con, SIGNAL(testEnded()), this, SLOT(conTestEnded()));
connect(con, SIGNAL(testResults(bool)), this, SLOT(conTestResults(bool)));
ui->boxConnection->setEnabled(true);
ui->boxOutput->setEnabled(true);
m_subviewModel = new PlayerSubviewsModel(con);
ui->subviewListview->setModel(m_subviewModel);
ui->subviewListview->setCurrentIndex(m_subviewModel->index(0,0));
GLWidgetSubview *sub = !con->subviews().isEmpty() ? con->subviews().at(0) : 0;
if(!sub)
con->addSubview(sub = new GLWidgetSubview());
if(sub->title().isEmpty())
sub->setTitle("Default Subview");
setCurrentSubview(sub);
}
static bool read_jpeg_image(QImage *outImage,
QSize scaledSize, QRect scaledClipRect,
QRect clipRect, int inQuality, j_decompress_ptr info, struct my_error_mgr* err )
{
if (!setjmp(err->setjmp_buffer)) {
// -1 means default quality.
int quality = inQuality;
if (quality < 0)
quality = 75;
// If possible, merge the scaledClipRect into either scaledSize
// or clipRect to avoid doing a separate scaled clipping pass.
// Best results are achieved by clipping before scaling, not after.
if (!scaledClipRect.isEmpty()) {
if (scaledSize.isEmpty() && clipRect.isEmpty()) {
// No clipping or scaling before final clip.
clipRect = scaledClipRect;
scaledClipRect = QRect();
} else if (scaledSize.isEmpty()) {
// Clipping, but no scaling: combine the clip regions.
scaledClipRect.translate(clipRect.topLeft());
clipRect = scaledClipRect.intersected(clipRect);
scaledClipRect = QRect();
} else if (clipRect.isEmpty()) {
// No clipping, but scaling: if we can map back to an
// integer pixel boundary, then clip before scaling.
if ((info->image_width % scaledSize.width()) == 0 &&
(info->image_height % scaledSize.height()) == 0) {
int x = scaledClipRect.x() * info->image_width /
scaledSize.width();
int y = scaledClipRect.y() * info->image_height /
scaledSize.height();
int width = (scaledClipRect.right() + 1) *
info->image_width / scaledSize.width() - x;
int height = (scaledClipRect.bottom() + 1) *
info->image_height / scaledSize.height() - y;
clipRect = QRect(x, y, width, height);
scaledSize = scaledClipRect.size();
scaledClipRect = QRect();
}
} else {
// Clipping and scaling: too difficult to figure out,
// and not a likely use case, so do it the long way.
}
}
// Determine the scale factor to pass to libjpeg for quick downscaling.
if (!scaledSize.isEmpty()) {
if (clipRect.isEmpty()) {
info->scale_denom =
qMin(info->image_width / scaledSize.width(),
info->image_height / scaledSize.height());
} else {
info->scale_denom =
qMin(clipRect.width() / scaledSize.width(),
clipRect.height() / scaledSize.height());
}
if (info->scale_denom < 2) {
info->scale_denom = 1;
} else if (info->scale_denom < 4) {
info->scale_denom = 2;
} else if (info->scale_denom < 8) {
info->scale_denom = 4;
} else {
info->scale_denom = 8;
}
info->scale_num = 1;
if (!clipRect.isEmpty()) {
// Correct the scale factor so that we clip accurately.
// It is recommended that the clip rectangle be aligned
// on an 8-pixel boundary for best performance.
while (info->scale_denom > 1 &&
((clipRect.x() % info->scale_denom) != 0 ||
(clipRect.y() % info->scale_denom) != 0 ||
(clipRect.width() % info->scale_denom) != 0 ||
(clipRect.height() % info->scale_denom) != 0)) {
info->scale_denom /= 2;
}
}
}
// If high quality not required, use fast decompression
if( quality < HIGH_QUALITY_THRESHOLD ) {
info->dct_method = JDCT_IFAST;
info->do_fancy_upsampling = FALSE;
}
(void) jpeg_calc_output_dimensions(info);
// Determine the clip region to extract.
QRect imageRect(0, 0, info->output_width, info->output_height);
QRect clip;
if (clipRect.isEmpty()) {
clip = imageRect;
} else if (info->scale_denom == info->scale_num) {
clip = clipRect.intersected(imageRect);
} else {
// The scale factor was corrected above to ensure that
// we don't miss pixels when we scale the clip rectangle.
clip = QRect(clipRect.x() / int(info->scale_denom),
clipRect.y() / int(info->scale_denom),
clipRect.width() / int(info->scale_denom),
clipRect.height() / int(info->scale_denom));
clip = clip.intersected(imageRect);
}
// Allocate memory for the clipped QImage.
if (!ensureValidImage(outImage, info, clip.size()))
longjmp(err->setjmp_buffer, 1);
// Avoid memcpy() overhead if grayscale with no clipping.
bool quickGray = (info->output_components == 1 &&
clip == imageRect);
if (!quickGray) {
// Ask the jpeg library to allocate a temporary row.
// The library will automatically delete it for us later.
// The libjpeg docs say we should do this before calling
// jpeg_start_decompress(). We can't use "new" here
// because we are inside the setjmp() block and an error
// in the jpeg input stream would cause a memory leak.
JSAMPARRAY rows = (info->mem->alloc_sarray)
((j_common_ptr)info, JPOOL_IMAGE,
info->output_width * info->output_components, 1);
(void) jpeg_start_decompress(info);
while (info->output_scanline < info->output_height) {
int y = int(info->output_scanline) - clip.y();
if (y >= clip.height())
break; // We've read the entire clip region, so abort.
(void) jpeg_read_scanlines(info, rows, 1);
if (y < 0)
continue; // Haven't reached the starting line yet.
if (info->output_components == 3) {
uchar *in = rows[0] + clip.x() * 3;
QRgb *out = (QRgb*)outImage->scanLine(y);
rgb888ToRgb32ConverterPtr(out, in, clip.width());
} else if (info->out_color_space == JCS_CMYK) {
// Convert CMYK->RGB.
uchar *in = rows[0] + clip.x() * 4;
QRgb *out = (QRgb*)outImage->scanLine(y);
for (int i = 0; i < clip.width(); ++i) {
int k = in[3];
*out++ = qRgb(k * in[0] / 255, k * in[1] / 255,
k * in[2] / 255);
in += 4;
}
} else if (info->output_components == 1) {
// Grayscale.
memcpy(outImage->scanLine(y),
rows[0] + clip.x(), clip.width());
}
}
} else {
// Load unclipped grayscale data directly into the QImage.
(void) jpeg_start_decompress(info);
while (info->output_scanline < info->output_height) {
uchar *row = outImage->scanLine(info->output_scanline);
(void) jpeg_read_scanlines(info, &row, 1);
}
}
if (info->output_scanline == info->output_height)
(void) jpeg_finish_decompress(info);
if (info->density_unit == 1) {
outImage->setDotsPerMeterX(int(100. * info->X_density / 2.54));
outImage->setDotsPerMeterY(int(100. * info->Y_density / 2.54));
} else if (info->density_unit == 2) {
outImage->setDotsPerMeterX(int(100. * info->X_density));
outImage->setDotsPerMeterY(int(100. * info->Y_density));
}
if (scaledSize.isValid() && scaledSize != clip.size()) {
*outImage = outImage->scaled(scaledSize, Qt::IgnoreAspectRatio, quality >= HIGH_QUALITY_THRESHOLD ? Qt::SmoothTransformation : Qt::FastTransformation);
}
if (!scaledClipRect.isEmpty())
*outImage = outImage->copy(scaledClipRect);
return !outImage->isNull();
}
else
return false;
}
void QFrame::drawFrame( QPainter *p )
{
QPoint p1, p2;
QRect r = frameRect();
int type = fstyle & MShape;
int cstyle = fstyle & MShadow;
#ifdef QT_NO_DRAWUTIL
p->setPen( black ); // ####
p->drawRect( r ); //### a bit too simple
#else
const QColorGroup & g = colorGroup();
#ifndef QT_NO_STYLE
QStyleOption opt(lineWidth(),midLineWidth());
QStyle::SFlags flags = QStyle::Style_Default;
if (isEnabled())
flags |= QStyle::Style_Enabled;
if (cstyle == Sunken)
flags |= QStyle::Style_Sunken;
else if (cstyle == Raised)
flags |= QStyle::Style_Raised;
if (hasFocus())
flags |= QStyle::Style_HasFocus;
if (hasMouse())
flags |= QStyle::Style_MouseOver;
#endif // QT_NO_STYLE
switch ( type ) {
case Box:
if ( cstyle == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
qDrawShadeRect( p, r, g, cstyle == Sunken, lwidth,
midLineWidth() );
break;
case LineEditPanel:
style().drawPrimitive( QStyle::PE_PanelLineEdit, p, r, g, flags, opt );
break;
case GroupBoxPanel:
style().drawPrimitive( QStyle::PE_PanelGroupBox, p, r, g, flags, opt );
break;
case TabWidgetPanel:
style().drawPrimitive( QStyle::PE_PanelTabWidget, p, r, g, flags, opt );
break;
case MenuBarPanel:
#ifndef QT_NO_STYLE
style().drawPrimitive(QStyle::PE_PanelMenuBar, p, r, g, flags, opt);
break;
#endif // fall through to Panel if QT_NO_STYLE
case ToolBarPanel:
#ifndef QT_NO_STYLE
style().drawPrimitive( QStyle::PE_PanelDockWindow, p, rect(), g, flags, opt);
break;
#endif // fall through to Panel if QT_NO_STYLE
case StyledPanel:
#ifndef QT_NO_STYLE
if ( cstyle == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
style().drawPrimitive(QStyle::PE_Panel, p, r, g, flags, opt);
break;
#endif // fall through to Panel if QT_NO_STYLE
case PopupPanel:
#ifndef QT_NO_STYLE
{
int vextra = style().pixelMetric(QStyle::PM_PopupMenuFrameVerticalExtra, this),
hextra = style().pixelMetric(QStyle::PM_PopupMenuFrameHorizontalExtra, this);
if(vextra > 0 || hextra > 0) {
QRect fr = frameRect();
int fw = frameWidth();
if(vextra > 0) {
style().drawControl(QStyle::CE_PopupMenuVerticalExtra, p, this,
QRect(fr.x() + fw, fr.y() + fw, fr.width() - (fw*2), vextra),
g, flags, opt);
style().drawControl(QStyle::CE_PopupMenuVerticalExtra, p, this,
QRect(fr.x() + fw, fr.bottom() - fw - vextra, fr.width() - (fw*2), vextra),
g, flags, opt);
}
if(hextra > 0) {
style().drawControl(QStyle::CE_PopupMenuHorizontalExtra, p, this,
QRect(fr.x() + fw, fr.y() + fw + vextra, hextra, fr.height() - (fw*2) - vextra),
g, flags, opt);
style().drawControl(QStyle::CE_PopupMenuHorizontalExtra, p, this,
QRect(fr.right() - fw - hextra, fr.y() + fw + vextra, hextra, fr.height() - (fw*2) - vextra),
g, flags, opt);
}
}
if ( cstyle == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
style().drawPrimitive(QStyle::PE_PanelPopup, p, r, g, flags, opt);
break;
}
#endif // fall through to Panel if QT_NO_STYLE
case Panel:
if ( cstyle == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
qDrawShadePanel( p, r, g, cstyle == Sunken, lwidth );
break;
case WinPanel:
if ( cstyle == Plain )
qDrawPlainRect( p, r, g.foreground(), wpwidth );
else
qDrawWinPanel( p, r, g, cstyle == Sunken );
break;
case HLine:
case VLine:
if ( type == HLine ) {
p1 = QPoint( r.x(), r.height()/2 );
p2 = QPoint( r.x()+r.width(), p1.y() );
}
else {
p1 = QPoint( r.x()+r.width()/2, 0 );
p2 = QPoint( p1.x(), r.height() );
}
if ( cstyle == Plain ) {
QPen oldPen = p->pen();
p->setPen( QPen(g.foreground(),lwidth) );
p->drawLine( p1, p2 );
p->setPen( oldPen );
}
else
qDrawShadeLine( p, p1, p2, g, cstyle == Sunken,
lwidth, midLineWidth() );
break;
}
#endif // QT_NO_DRAWUTIL
}
void RtKeyboard::MouseFuncPress(int iPressY,int iIndex)
{
iPressY = 0;
QPoint keyOffset = QPoint(-10,-60);
QRect rectPressBtn = m_pFuncButton[iIndex]->geometry();
QString strKey;
QRect rectBtnText = QRect(18,16,15,15);
//Delete the Select Key, if it is exist.
if(m_pSelectKey) {
delete m_pSelectKey;
m_pSelectKey = NULL;
}
QWidget *parent = (QWidget*)this->parent();
if(parent == NULL)
parent = this;
strKey = m_pFuncButton[iIndex]->text();
QRect rectKeyboard = this->geometry();
int iSrcWidth = rectKeyboard.x()+rectPressBtn.x()+keyOffset.x();
int iSrcHeight = rectKeyboard.y()+rectPressBtn.y()+keyOffset.y();
m_pSelectKey = new RtKeyButton(parent);
if(iIndex == __FUN_KEY_0__)
{
m_pSelectKey->SetImages(&m_Key4[1],&m_Key4[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key4[1].width(),m_Key4[1].height());
}
else if(iIndex == __FUN_KEY_1__)//Function Key #1
{
m_pSelectKey->SetImages(&m_Key_Switch[1],&m_Key_Switch[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key_Switch[1].width(),m_Key_Switch[1].height());
}
else if(iIndex == __FUN_KEY_2__)//Function Key #2
{
QRect rectFun2Text = QRect(18,16,30,15);
m_pSelectKey->setButtonText(strKey,rectFun2Text);
m_pSelectKey->SetImages(&m_Key_Del[1],&m_Key_Del[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key_Del[1].width(),m_Key_Del[1].height());
}
else if(iIndex == __FUN_KEY_3__)//Function Key #3
{
QRect rectFun3Text = QRect(14,16,35,15);
m_pSelectKey->SetImages(&m_Key7[1],&m_Key7[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key7[1].width(),m_Key7[1].height());
m_pSelectKey->setButtonText(strKey,rectFun3Text);
}
else if(iIndex == __FUN_KEY_4__)//Function Key #4
{
QRect rectFun4Text = QRect(18,16,30,15);
m_pSelectKey->SetImages(&m_Key_Enter[1],&m_Key_Enter[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key_Enter[1].width(),m_Key_Enter[1].height());
m_pSelectKey->setButtonText(strKey,rectFun4Text);
}
else if(iIndex == __FUN_KEY_5__)//Function Key #5
{
m_pSelectKey->SetImages(&m_Key3[1],&m_Key3[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key3[1].width(),m_Key3[1].height());
m_pSelectKey->setButtonText(strKey,rectBtnText);
}
else if(iIndex == __FUN_KEY_6__)//Function Key #6
{
m_pSelectKey->SetImages(&m_Key3[1],&m_Key3[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key3[1].width(),m_Key3[1].height());
m_pSelectKey->setButtonText(strKey,rectBtnText);
}
m_pSelectKey->setAlignStyle(RtKeyButton::AlignCenter);
m_pSelectKey->setEnabled(false);
m_pSelectKey->show();
}
void KisFilterFastColorTransfer::processImpl(KisPaintDeviceSP device,
const QRect& applyRect,
const KisFilterConfiguration* config,
KoUpdater* progressUpdater) const
{
Q_ASSERT(device != 0);
dbgPlugins << "Start transferring color";
// Convert ref and src to LAB
const KoColorSpace* labCS = KoColorSpaceRegistry::instance()->lab16();
if (!labCS) {
dbgPlugins << "The LAB colorspace is not available.";
return;
}
dbgPlugins << "convert a copy of src to lab";
const KoColorSpace* oldCS = device->colorSpace();
KisPaintDeviceSP srcLAB = new KisPaintDevice(*device.data());
dbgPlugins << "srcLab : " << srcLAB->extent();
KUndo2Command* cmd = srcLAB->convertTo(labCS, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
delete cmd;
if (progressUpdater) {
progressUpdater->setRange(0, 2 * applyRect.width() * applyRect.height());
}
int count = 0;
// Compute the means and sigmas of src
dbgPlugins << "Compute the means and sigmas of src";
double meanL_src = 0., meanA_src = 0., meanB_src = 0.;
double sigmaL_src = 0., sigmaA_src = 0., sigmaB_src = 0.;
KisSequentialConstIterator srcIt(srcLAB, applyRect);
do {
const quint16* data = reinterpret_cast<const quint16*>(srcIt.oldRawData());
quint32 L = data[0];
quint32 A = data[1];
quint32 B = data[2];
meanL_src += L;
meanA_src += A;
meanB_src += B;
sigmaL_src += L * L;
sigmaA_src += A * A;
sigmaB_src += B * B;
if (progressUpdater) progressUpdater->setValue(++count);
} while (srcIt.nextPixel() && !(progressUpdater && progressUpdater->interrupted()));
double totalSize = 1. / (applyRect.width() * applyRect.height());
meanL_src *= totalSize;
meanA_src *= totalSize;
meanB_src *= totalSize;
sigmaL_src *= totalSize;
sigmaA_src *= totalSize;
sigmaB_src *= totalSize;
dbgPlugins << totalSize << "" << meanL_src << "" << meanA_src << "" << meanB_src << "" << sigmaL_src << "" << sigmaA_src << "" << sigmaB_src;
double meanL_ref = config->getDouble("meanL");
double meanA_ref = config->getDouble("meanA");
double meanB_ref = config->getDouble("meanB");
double sigmaL_ref = config->getDouble("sigmaL");
double sigmaA_ref = config->getDouble("sigmaA");
double sigmaB_ref = config->getDouble("sigmaB");
// Transfer colors
dbgPlugins << "Transfer colors";
{
double coefL = sqrt((sigmaL_ref - meanL_ref * meanL_ref) / (sigmaL_src - meanL_src * meanL_src));
double coefA = sqrt((sigmaA_ref - meanA_ref * meanA_ref) / (sigmaA_src - meanA_src * meanA_src));
double coefB = sqrt((sigmaB_ref - meanB_ref * meanB_ref) / (sigmaB_src - meanB_src * meanB_src));
KisHLineConstIteratorSP srcLABIt = srcLAB->createHLineConstIteratorNG(applyRect.x(), applyRect.y(), applyRect.width());
KisHLineIteratorSP dstIt = device->createHLineIteratorNG(applyRect.x(), applyRect.y(), applyRect.width());
quint16 labPixel[4];
for (int y = 0; y < applyRect.height() && !(progressUpdater && progressUpdater->interrupted()); ++y) {
do {
const quint16* data = reinterpret_cast<const quint16*>(srcLABIt->oldRawData());
labPixel[0] = (quint16)CLAMP(((double)data[0] - meanL_src) * coefL + meanL_ref, 0., 65535.);
labPixel[1] = (quint16)CLAMP(((double)data[1] - meanA_src) * coefA + meanA_ref, 0., 65535.);
labPixel[2] = (quint16)CLAMP(((double)data[2] - meanB_src) * coefB + meanB_ref, 0., 65535.);
labPixel[3] = data[3];
oldCS->fromLabA16(reinterpret_cast<const quint8*>(labPixel), dstIt->rawData(), 1);
if (progressUpdater) progressUpdater->setValue(++count);
srcLABIt->nextPixel();
} while(dstIt->nextPixel());
dstIt->nextRow();
srcLABIt->nextRow();
}
}
}
void RtKeyboard::MousePress(int iPressY,int iIndex)
{
iPressY = 0;
QPoint keyOffset = QPoint( -10,-60);
QRect rectBtnText = QRect(18,16,15,15);
QString strKey;
QRect rectPressBtn;
if(m_KeypadFlag == KEYPAD_AZ)
rectPressBtn = m_pKeyButton[iIndex]->geometry();
else if(m_KeypadFlag == KEYPAD_09)
rectPressBtn = m_pNumberButton[iIndex]->geometry();
//Delete the Select Key, if it is exist.
if(m_pSelectKey) {
delete m_pSelectKey;
m_pSelectKey = NULL;
}
QWidget *parent = (QWidget*)this->parent();
if(parent == NULL)
parent = this;
if(m_KeypadFlag == KEYPAD_AZ)
{
strKey = m_pKeyButton[iIndex]->text();
}
else if(m_KeypadFlag == KEYPAD_09)
{
strKey = m_pNumberButton[iIndex]->text();
}
QRect rectKeyboard = this->geometry();
int iSrcWidth = rectKeyboard.x()+rectPressBtn.x()+keyOffset.x();
int iSrcHeight = rectKeyboard.y()+rectPressBtn.y()+keyOffset.y();
m_pSelectKey = new RtKeyButton(parent);
m_pSelectKey->SetImages(&m_Key1[1],&m_Key1[1]);
m_pSelectKey->setGeometry(iSrcWidth,iSrcHeight,m_Key1[1].width(),m_Key1[1].height());
m_pSelectKey->setButtonText(strKey,rectBtnText);
m_pSelectKey->setAlignStyle(RtKeyButton::AlignCenter);
m_pSelectKey->setEnabled(false);
QString strTmp = strKey.toLower();
QString strChar[]={"a","c","e","i","n","o","s","u","y"};
m_strExtKey = "";
bool bExtKey = false;
for(int i=0;i<9;i++)
{
if(strTmp.compare(strChar[i])==0){
m_strExtKey = strKey;
bExtKey = true;
break;
}
}
if(bExtKey){
m_pSelectKey->setExtKey(bExtKey);
m_pExtTimer->start(1000);
}
m_pSelectKey->show();
}
void HexagonalRenderer::drawGrid(QPainter *painter, const QRectF &exposed,
QColor gridColor) const
{
QRect rect = exposed.toAlignedRect();
if (rect.isNull())
return;
const RenderParams p(map());
// Determine the tile and pixel coordinates to start at
QPoint startTile = screenToTileCoords(rect.topLeft()).toPoint();
QPoint startPos = tileToScreenCoords(startTile).toPoint();
/* Determine in which half of the tile the top-left corner of the area we
* need to draw is. If we're in the upper half, we need to start one row
* up due to those tiles being visible as well. How we go up one row
* depends on whether we're in the left or right half of the tile.
*/
const bool inUpperHalf = rect.y() - startPos.y() < p.sideOffsetY;
const bool inLeftHalf = rect.x() - startPos.x() < p.sideOffsetX;
if (inUpperHalf)
startTile.ry()--;
if (inLeftHalf)
startTile.rx()--;
startTile.setX(qMax(0, startTile.x()));
startTile.setY(qMax(0, startTile.y()));
startPos = tileToScreenCoords(startTile).toPoint();
const QPoint oct[8] = {
QPoint(0, p.tileHeight - p.sideOffsetY),
QPoint(0, p.sideOffsetY),
QPoint(p.sideOffsetX, 0),
QPoint(p.tileWidth - p.sideOffsetX, 0),
QPoint(p.tileWidth, p.sideOffsetY),
QPoint(p.tileWidth, p.tileHeight - p.sideOffsetY),
QPoint(p.tileWidth - p.sideOffsetX, p.tileHeight),
QPoint(p.sideOffsetX, p.tileHeight)
};
QVector<QLine> lines;
lines.reserve(8);
gridColor.setAlpha(128);
QPen gridPen(gridColor);
gridPen.setCosmetic(true);
gridPen.setDashPattern(QVector<qreal>() << 2 << 2);
painter->setPen(gridPen);
if (p.staggerX) {
// Odd row shifting is applied in the rendering loop, so un-apply it here
if (p.doStaggerX(startTile.x()))
startPos.ry() -= p.rowHeight;
for (; startPos.x() <= rect.right() && startTile.x() < map()->width(); startTile.rx()++) {
QPoint rowTile = startTile;
QPoint rowPos = startPos;
if (p.doStaggerX(startTile.x()))
rowPos.ry() += p.rowHeight;
for (; rowPos.y() <= rect.bottom() && rowTile.y() < map()->height(); rowTile.ry()++) {
lines.append(QLine(rowPos + oct[1], rowPos + oct[2]));
lines.append(QLine(rowPos + oct[2], rowPos + oct[3]));
lines.append(QLine(rowPos + oct[3], rowPos + oct[4]));
const bool isStaggered = p.doStaggerX(startTile.x());
const bool lastRow = rowTile.y() == map()->height() - 1;
const bool lastColumn = rowTile.x() == map()->width() - 1;
const bool bottomLeft = rowTile.x() == 0 || (lastRow && isStaggered);
const bool bottomRight = lastColumn || (lastRow && isStaggered);
if (bottomRight)
lines.append(QLine(rowPos + oct[5], rowPos + oct[6]));
if (lastRow)
lines.append(QLine(rowPos + oct[6], rowPos + oct[7]));
if (bottomLeft)
lines.append(QLine(rowPos + oct[7], rowPos + oct[0]));
painter->drawLines(lines);
lines.resize(0);
rowPos.ry() += p.tileHeight + p.sideLengthY;
}
startPos.rx() += p.columnWidth;
}
} else {
// Odd row shifting is applied in the rendering loop, so un-apply it here
if (p.doStaggerY(startTile.y()))
startPos.rx() -= p.columnWidth;
for (; startPos.y() <= rect.bottom() && startTile.y() < map()->height(); startTile.ry()++) {
QPoint rowTile = startTile;
QPoint rowPos = startPos;
if (p.doStaggerY(startTile.y()))
rowPos.rx() += p.columnWidth;
for (; rowPos.x() <= rect.right() && rowTile.x() < map()->width(); rowTile.rx()++) {
lines.append(QLine(rowPos + oct[0], rowPos + oct[1]));
lines.append(QLine(rowPos + oct[1], rowPos + oct[2]));
lines.append(QLine(rowPos + oct[3], rowPos + oct[4]));
const bool isStaggered = p.doStaggerY(startTile.y());
const bool lastRow = rowTile.y() == map()->height() - 1;
const bool lastColumn = rowTile.x() == map()->width() - 1;
const bool bottomLeft = lastRow || (rowTile.x() == 0 && !isStaggered);
const bool bottomRight = lastRow || (lastColumn && isStaggered);
if (lastColumn)
lines.append(QLine(rowPos + oct[4], rowPos + oct[5]));
if (bottomRight)
lines.append(QLine(rowPos + oct[5], rowPos + oct[6]));
if (bottomLeft)
lines.append(QLine(rowPos + oct[7], rowPos + oct[0]));
painter->drawLines(lines);
lines.resize(0);
rowPos.rx() += p.tileWidth + p.sideLengthX;
}
startPos.ry() += p.rowHeight;
}
}
}
void ArthurFrame::paintEvent(QPaintEvent *e)
{
#ifdef Q_WS_QWS
static QPixmap *static_image = 0;
#else
static QImage *static_image = 0;
#endif
QPainter painter;
if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
if (!static_image || static_image->size() != size()) {
delete static_image;
#ifdef Q_WS_QWS
static_image = new QPixmap(size());
#else
static_image = new QImage(size(), QImage::Format_RGB32);
#endif
}
painter.begin(static_image);
int o = 10;
QBrush bg = palette().brush(QPalette::Background);
painter.fillRect(0, 0, o, o, bg);
painter.fillRect(width() - o, 0, o, o, bg);
painter.fillRect(0, height() - o, o, o, bg);
painter.fillRect(width() - o, height() - o, o, o, bg);
} else {
#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl) {
painter.begin(glw);
painter.fillRect(QRectF(0, 0, glw->width(), glw->height()), palette().color(backgroundRole()));
} else {
painter.begin(this);
}
#else
painter.begin(this);
#endif
}
painter.setClipRect(e->rect());
painter.setRenderHint(QPainter::Antialiasing);
QPainterPath clipPath;
QRect r = rect();
qreal left = r.x() + 1;
qreal top = r.y() + 1;
qreal right = r.right();
qreal bottom = r.bottom();
qreal radius2 = 8 * 2;
clipPath.moveTo(right - radius2, top);
clipPath.arcTo(right - radius2, top, radius2, radius2, 90, -90);
clipPath.arcTo(right - radius2, bottom - radius2, radius2, radius2, 0, -90);
clipPath.arcTo(left, bottom - radius2, radius2, radius2, 270, -90);
clipPath.arcTo(left, top, radius2, radius2, 180, -90);
clipPath.closeSubpath();
painter.save();
painter.setClipPath(clipPath, Qt::IntersectClip);
painter.drawTiledPixmap(rect(), m_tile);
// client painting
paint(&painter);
painter.restore();
painter.save();
if (m_show_doc)
paintDescription(&painter);
painter.restore();
int level = 180;
painter.setPen(QPen(QColor(level, level, level), 2));
painter.setBrush(Qt::NoBrush);
painter.drawPath(clipPath);
if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
painter.end();
painter.begin(this);
#ifdef Q_WS_QWS
painter.drawPixmap(e->rect(), *static_image, e->rect());
#else
painter.drawImage(e->rect(), *static_image, e->rect());
#endif
}
#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl && (inherits("PathDeformRenderer") || inherits("PathStrokeRenderer") || inherits("CompositionRenderer") || m_show_doc))
glw->swapBuffers();
#endif
}
// 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(QLatin1String("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 StaggeredRenderer::drawTileLayer(QPainter *painter,
const TileLayer *layer,
const QRectF &exposed) const
{
const int tileWidth = map()->tileWidth();
const int tileHeight = map()->tileHeight();
QRect rect = exposed.toAlignedRect();
if (rect.isNull())
rect = boundingRect(layer->bounds());
QMargins drawMargins = layer->drawMargins();
drawMargins.setRight(drawMargins.right() - tileWidth);
rect.adjust(-drawMargins.right(),
-drawMargins.bottom(),
drawMargins.left(),
drawMargins.top());
// Determine the tile and pixel coordinates to start at
QPoint startTile = pixelToTileCoords(rect.x(), rect.y()).toPoint();
// Compensate for the layer position
startTile -= layer->position();
QPoint startPos = tileToPixelCoords(startTile + layer->position()).toPoint();
/* Determine in which half of the tile the top-left corner of the area we
* need to draw is. If we're in the upper half, we need to start one row
* up due to those tiles being visible as well. How we go up one row
* depends on whether we're in the left or right half of the tile.
*/
const bool inUpperHalf = startPos.y() - rect.y() > tileHeight / 2;
const bool inLeftHalf = rect.x() - startPos.x() < tileWidth / 2;
if (inUpperHalf)
startTile.ry()--;
if (inLeftHalf)
startTile.rx()--;
startTile.setX(qMax(0, startTile.x()));
startTile.setY(qMax(0, startTile.y()));
startPos = tileToPixelCoords(startTile + layer->position()).toPoint();
startPos.ry() += tileHeight;
// Odd row shifting is applied in the rendering loop, so un-apply it here
if ((startTile.y() + layer->y()) % 2)
startPos.rx() -= tileWidth / 2;
qDebug() << rect << startTile << startPos << layer->position();
QTransform baseTransform = painter->transform();
for (; startPos.y() < rect.bottom() && startTile.y() < layer->height(); startTile.ry()++) {
QPoint rowTile = startTile;
QPoint rowPos = startPos;
if ((startTile.y() + layer->y()) % 2)
rowPos.rx() += tileWidth / 2;
for (; rowPos.x() < rect.right() && rowTile.x() < layer->width(); rowTile.rx()++) {
const Cell &cell = layer->cellAt(rowTile);
if (cell.isEmpty()) {
rowPos.rx() += tileWidth;
continue;
}
#ifdef ZOMBOID
const QImage &img = cell.tile->image();
#else
const QPixmap &img = cell.tile->image();
#endif
const QPoint offset = cell.tile->tileset()->tileOffset();
qreal m11 = 1; // Horizontal scaling factor
qreal m12 = 0; // Vertical shearing factor
qreal m21 = 0; // Horizontal shearing factor
qreal m22 = 1; // Vertical scaling factor
qreal dx = offset.x() + rowPos.x();
qreal dy = offset.y() + rowPos.y() - img.height();
if (cell.flippedAntiDiagonally) {
// Use shearing to swap the X/Y axis
m11 = 0;
m12 = 1;
m21 = 1;
m22 = 0;
// Compensate for the swap of image dimensions
dy += img.height() - img.width();
}
if (cell.flippedHorizontally) {
m11 = -m11;
m21 = -m21;
dx += cell.flippedAntiDiagonally ? img.height()
: img.width();
}
if (cell.flippedVertically) {
m12 = -m12;
m22 = -m22;
dy += cell.flippedAntiDiagonally ? img.width()
: img.height();
}
const QTransform transform(m11, m12, m21, m22, dx, dy);
painter->setTransform(transform * baseTransform);
#ifdef ZOMBOID
painter->drawImage(0, 0, img);
#else
painter->drawPixmap(0, 0, img);
#endif
rowPos.rx() += tileWidth;
}
startPos.ry() += tileHeight / 2;
}
painter->setTransform(baseTransform);
}
void PieView::paintEvent(QPaintEvent *event)
{
QItemSelectionModel *selections = selectionModel();
QStyleOptionViewItem option = viewOptions();
QStyle::State state = option.state;
QBrush background = option.palette.base();
QPen foreground(option.palette.color(QPalette::WindowText));
QPen textPen(option.palette.color(QPalette::Text));
QPen highlightedPen(option.palette.color(QPalette::HighlightedText));
QPainter painter(viewport());
painter.setRenderHint(QPainter::Antialiasing);
painter.fillRect(event->rect(), background);
painter.setPen(foreground);
// Viewport rectangles
QRect pieRect = QRect(margin, margin, pieSize, pieSize);
QPoint keyPoint = QPoint(totalSize - horizontalScrollBar()->value(),
margin - verticalScrollBar()->value());
if (validItems > 0) {
painter.save();
painter.translate(pieRect.x() - horizontalScrollBar()->value(),
pieRect.y() - verticalScrollBar()->value());
painter.drawEllipse(0, 0, pieSize, pieSize);
double startAngle = 0.0;
int row;
for (row = 0; row < model()->rowCount(rootIndex()); ++row) {
QModelIndex index = model()->index(row, 1, rootIndex());
double value = model()->data(index).toDouble();
if (value > 0.0) {
double angle = 360*value/totalValue;
QModelIndex colorIndex = model()->index(row, 0, rootIndex());
QColor color = QColor(model()->data(colorIndex,
Qt::DecorationRole).toString());
if (currentIndex() == index)
painter.setBrush(QBrush(color, Qt::Dense4Pattern));
else if (selections->isSelected(index))
painter.setBrush(QBrush(color, Qt::Dense3Pattern));
else
painter.setBrush(QBrush(color));
painter.drawPie(0, 0, pieSize, pieSize, int(startAngle*16),
int(angle*16));
startAngle += angle;
}
}
painter.restore();
int keyNumber = 0;
for (row = 0; row < model()->rowCount(rootIndex()); ++row) {
QModelIndex index = model()->index(row, 1, rootIndex());
double value = model()->data(index).toDouble();
if (value > 0.0) {
QModelIndex labelIndex = model()->index(row, 0, rootIndex());
QStyleOptionViewItem option = viewOptions();
option.rect = visualRect(labelIndex);
if (selections->isSelected(labelIndex))
option.state |= QStyle::State_Selected;
if (currentIndex() == labelIndex)
option.state |= QStyle::State_HasFocus;
itemDelegate()->paint(&painter, option, labelIndex);
keyNumber++;
}
}
}
}
const Glyph& TextRenderer::getGlyph(char c) {
Glyph& glyph = _glyphs[c];
if (glyph.isValid()) {
return glyph;
}
// we use 'J' as a representative size for the solid block character
QChar ch = (c == SOLID_BLOCK_CHAR) ? QChar('J') : QChar(c);
QRect bounds = _metrics.boundingRect(ch);
if (bounds.isEmpty()) {
glyph = Glyph(0, QPoint(), QRect(), _metrics.width(ch));
return glyph;
}
// grow the bounds to account for effect, if any
if (_effectType == SHADOW_EFFECT) {
bounds.adjust(-_effectThickness, 0, 0, _effectThickness);
} else if (_effectType == OUTLINE_EFFECT) {
bounds.adjust(-_effectThickness, -_effectThickness, _effectThickness, _effectThickness);
}
// grow the bounds to account for antialiasing
bounds.adjust(-1, -1, 1, 1);
if (_x + bounds.width() > IMAGE_SIZE) {
// we can't fit it on the current row; move to next
_y += _rowHeight;
_x = _rowHeight = 0;
}
if (_y + bounds.height() > IMAGE_SIZE) {
// can't fit it on current texture; make a new one
glGenTextures(1, &_currentTextureID);
_x = _y = _rowHeight = 0;
glBindTexture(GL_TEXTURE_2D, _currentTextureID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, IMAGE_SIZE, IMAGE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
_allTextureIDs.append(_currentTextureID);
} else {
glBindTexture(GL_TEXTURE_2D, _currentTextureID);
}
// render the glyph into an image and copy it into the texture
QImage image(bounds.width(), bounds.height(), QImage::Format_ARGB32);
if (c == SOLID_BLOCK_CHAR) {
image.fill(QColor(255, 255, 255));
} else {
image.fill(0);
QPainter painter(&image);
painter.setFont(_font);
if (_effectType == SHADOW_EFFECT) {
for (int i = 0; i < _effectThickness; i++) {
painter.drawText(-bounds.x() - 1 - i, -bounds.y() + 1 + i, ch);
}
} else if (_effectType == OUTLINE_EFFECT) {
QPainterPath path;
QFont font = _font;
font.setStyleStrategy(QFont::ForceOutline);
path.addText(-bounds.x() - 0.5, -bounds.y() + 0.5, font, ch);
QPen pen;
pen.setWidth(_effectThickness);
pen.setJoinStyle(Qt::RoundJoin);
pen.setCapStyle(Qt::RoundCap);
painter.setPen(pen);
painter.setRenderHint(QPainter::Antialiasing);
painter.drawPath(path);
}
painter.setPen(QColor(255, 255, 255));
painter.drawText(-bounds.x(), -bounds.y(), ch);
}
glTexSubImage2D(GL_TEXTURE_2D, 0, _x, _y, bounds.width(), bounds.height(), GL_RGBA, GL_UNSIGNED_BYTE, image.constBits());
glyph = Glyph(_currentTextureID, QPoint(_x, _y), bounds, _metrics.width(ch));
_x += bounds.width();
_rowHeight = qMax(_rowHeight, bounds.height());
glBindTexture(GL_TEXTURE_2D, 0);
return glyph;
}
static cv::Rect fromQRect(const QRect& rect)
{
return cv::Rect(rect.x(), rect.y(), rect.width(), rect.height());
}
void CameraView::newMouseData(struct MouseData mouseData)
{
QRect selectionBox;
// Set ROI
if(mouseData.leftButtonRelease)
{
int roiX = mouseData.selectionBox.x();
int roiY = mouseData.selectionBox.y();
int roiW = mouseData.selectionBox.width();
int roiH = mouseData.selectionBox.height();
int frameW = ui->frameLabel->width();
int frameH = ui->frameLabel->height();
// Copy box dimensions from mouseData to taskData
if(roiW < 0)
{
roiX = roiX + roiW;
roiW = roiW*-1;
}
if(roiH < 0)
{
roiY = roiY + roiH;
roiH = roiH*-1;
}
selectionBox.setX(roiX-(frameW-capW)/2);
selectionBox.setY(roiY-(frameH-capH)/2);
selectionBox.setWidth(roiW);
selectionBox.setHeight(roiH);
INFOMSG((">>> froi(%d,%d[%d,%d]) roi(%d,%d[%d,%d]) cap(%d,%d) frame(%d,%d)",selectionBox.x(),selectionBox.y(),selectionBox.width(),selectionBox.height(),roiX,roiY,roiW,roiH,capW,capH,frameW,frameH));
if(processingThread->resizeToFitWindow)
{
double ratioW = (double)capW/(double)frameW;
double ratioH = (double)capH/(double)frameH;
selectionBox.setX((double)roiX*ratioW);
selectionBox.setY((double)roiY*ratioH);
selectionBox.setWidth((double)roiW*ratioW);
selectionBox.setHeight((double)roiH*ratioH);
INFOMSG((">>> froi(%d,%d[%d,%d]) roi(%d,%d[%d,%d]) cap(%d,%d) frame(%d,%d)",selectionBox.x(),selectionBox.y(),selectionBox.width(),selectionBox.height(),roiX,roiY,roiW,roiH,capW,capH,frameW,frameH));
}
if((selectionBox.x()<0)||(selectionBox.y()<0)||
((selectionBox.x()+selectionBox.width())>capW)||
((selectionBox.y()+selectionBox.height())>capH) || roiW <=0 || roiH <= 0)
{
// Display error message
// QMessageBox::warning(this,"ERROR:","Selection box outside range. Please try again.");
WARNMSG(("ROI out of range"));
}else{
INFOMSG(("NEW ROI x,y(%d,%d) w,h(%d,%d)",selectionBox.x(),selectionBox.y(),selectionBox.width(),selectionBox.height()));
emit setROI(selectionBox);
}
}
}
