void ProgressBar::paintEvent(QPaintEvent *) { // TODO move font into stylehelper // TODO use stylehelper white double range = maximum() - minimum(); double percent = 0.50; if (range != 0) percent = (value() - minimum()) / range; if (percent > 1) percent = 1; else if (percent < 0) percent = 0; QPainter p(this); QFont boldFont(p.font()); boldFont.setPointSizeF(StyleHelper::sidebarFontSize()); boldFont.setBold(true); p.setFont(boldFont); QFontMetrics fm(boldFont); // Draw separator int h = fm.height(); p.setPen(QColor(0, 0, 0, 70)); p.drawLine(0,0, size().width(), 0); p.setPen(QColor(255, 255, 255, 70)); p.drawLine(0, 1, size().width(), 1); p.setPen(StyleHelper::panelTextColor()); p.drawText(QPoint(7, h+1), m_title); m_progressHeight = h-4; m_progressHeight += ((m_progressHeight % 2) + 1) % 2; // make odd // draw outer rect QRect rect(INDENT, h+6, size().width()-2*INDENT-m_progressHeight+1, m_progressHeight-1); p.setPen(StyleHelper::panelTextColor()); p.drawRect(rect); // draw inner rect QColor c = StyleHelper::panelTextColor(); c.setAlpha(180); p.setPen(Qt::NoPen); p.setBrush(c); QRect inner = rect.adjusted(2, 2, -1, -1); inner.adjust(0, 0, qRound((percent - 1) * inner.width()), 0); if (m_error) { // TODO this is not fancy enough QColor red(255, 0, 0, 180); p.setBrush(red); // avoid too small red bar if (inner.width() < 10) inner.adjust(0, 0, 10 - inner.width(), 0); } else if (value() == maximum()) { QColor green(140, 255, 140, 180); p.setBrush(green); } p.drawRect(inner); if (value() < maximum() && !m_error) { // draw cancel thingy // TODO this is quite ugly at the moment p.setPen(StyleHelper::panelTextColor()); p.setBrush(QBrush(Qt::NoBrush)); QRect cancelRect(size().width()-INDENT-m_progressHeight+3, h+6+1, m_progressHeight-3, m_progressHeight-3); p.drawRect(cancelRect); p.setPen(c); p.drawLine(cancelRect.center()+QPoint(-1,-1), cancelRect.center()+QPoint(+3,+3)); p.drawLine(cancelRect.center()+QPoint(+3,-1), cancelRect.center()+QPoint(-1,+3)); } }
void QgsDecorationScaleBar::render( QPainter * theQPainter ) { QgsMapCanvas* canvas = QgisApp::instance()->mapCanvas(); int myBufferSize = 1; //softcode this later //Get canvas dimensions int myCanvasHeight = theQPainter->device()->height(); int myCanvasWidth = theQPainter->device()->width(); //Get map units per pixel. This can be negative at times (to do with //projections) and that just confuses the rest of the code in this //function, so force to a positive number. double myMapUnitsPerPixelDouble = qAbs( canvas->mapUnitsPerPixel() ); double myActualSize = mPreferredSize; // Exit if the canvas width is 0 or layercount is 0 or QGIS will freeze int myLayerCount = canvas->layerCount(); if ( !myLayerCount || !myCanvasWidth || !myMapUnitsPerPixelDouble ) return; //Large if statement which determines whether to render the scale bar if ( enabled() ) { // Hard coded sizes int myMajorTickSize = 8; int myTextOffsetX = 3; int myMargin = 20; QSettings settings; QGis::UnitType myPreferredUnits = QGis::fromLiteral( settings.value( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) ).toString() ); QGis::UnitType myMapUnits = canvas->mapUnits(); // Adjust units meter/feet/... or vice versa myMapUnitsPerPixelDouble *= QGis::fromUnitToUnitFactor( myMapUnits, myPreferredUnits ); myMapUnits = myPreferredUnits; //Calculate size of scale bar for preferred number of map units double myScaleBarWidth = mPreferredSize / myMapUnitsPerPixelDouble; //If scale bar is very small reset to 1/4 of the canvas wide if ( myScaleBarWidth < 30 ) { myScaleBarWidth = myCanvasWidth / 4; // pixels myActualSize = myScaleBarWidth * myMapUnitsPerPixelDouble; // map units }; //if scale bar is more than half the canvas wide keep halving until not while ( myScaleBarWidth > myCanvasWidth / 3 ) { myScaleBarWidth = myScaleBarWidth / 3; }; myActualSize = myScaleBarWidth * myMapUnitsPerPixelDouble; // Work out the exponent for the number - e.g, 1234 will give 3, // and .001234 will give -3 double myPowerOf10 = floor( log10( myActualSize ) ); // snap to integer < 10 times power of 10 if ( mSnapping ) { double scaler = pow( 10.0, myPowerOf10 ); myActualSize = qRound( myActualSize / scaler ) * scaler; myScaleBarWidth = myActualSize / myMapUnitsPerPixelDouble; } //Get type of map units and set scale bar unit label text QString myScaleBarUnitLabel; switch ( myMapUnits ) { case QGis::Meters: if ( myActualSize > 1000.0 ) { myScaleBarUnitLabel = tr( " km" ); myActualSize = myActualSize / 1000; } else if ( myActualSize < 0.01 ) { myScaleBarUnitLabel = tr( " mm" ); myActualSize = myActualSize * 1000; } else if ( myActualSize < 0.1 ) { myScaleBarUnitLabel = tr( " cm" ); myActualSize = myActualSize * 100; } else myScaleBarUnitLabel = tr( " m" ); break; case QGis::Feet: if ( myActualSize > 5280.0 ) //5280 feet to the mile { myScaleBarUnitLabel = tr( " miles" ); // Adjust scale bar width to get even numbers myActualSize = myActualSize / 5000; myScaleBarWidth = ( myScaleBarWidth * 5280 ) / 5000; } else if ( myActualSize == 5280.0 ) //5280 feet to the mile { myScaleBarUnitLabel = tr( " mile" ); // Adjust scale bar width to get even numbers myActualSize = myActualSize / 5000; myScaleBarWidth = ( myScaleBarWidth * 5280 ) / 5000; } else if ( myActualSize < 1 ) { myScaleBarUnitLabel = tr( " inches" ); myActualSize = myActualSize * 10; myScaleBarWidth = ( myScaleBarWidth * 10 ) / 12; } else if ( myActualSize == 1.0 ) { myScaleBarUnitLabel = tr( " foot" ); } else { myScaleBarUnitLabel = tr( " feet" ); } break; case QGis::Degrees: if ( myActualSize == 1.0 ) myScaleBarUnitLabel = tr( " degree" ); else myScaleBarUnitLabel = tr( " degrees" ); break; case QGis::UnknownUnit: myScaleBarUnitLabel = tr( " unknown" ); default: QgsDebugMsg( QString( "Error: not picked up map units - actual value = %1" ).arg( myMapUnits ) ); }; //Set font and calculate width of unit label int myFontSize = 10; //we use this later for buffering QFont myFont( "helvetica", myFontSize ); theQPainter->setFont( myFont ); QFontMetrics myFontMetrics( myFont ); double myFontWidth = myFontMetrics.width( myScaleBarUnitLabel ); double myFontHeight = myFontMetrics.height(); //Set the maximum label QString myScaleBarMaxLabel = QLocale::system().toString( myActualSize ); //Calculate total width of scale bar and label double myTotalScaleBarWidth = myScaleBarWidth + myFontWidth; //determine the origin of scale bar depending on placement selected int myOriginX = myMargin; int myOriginY = myMargin; switch ( mPlacementIndex ) { case 0: // Bottom Left myOriginX = myMargin; myOriginY = myCanvasHeight - myMargin; break; case 1: // Top Left myOriginX = myMargin; myOriginY = myMargin; break; case 2: // Top Right myOriginX = myCanvasWidth - (( int ) myTotalScaleBarWidth ) - myMargin; myOriginY = myMargin; break; case 3: // Bottom Right myOriginX = myCanvasWidth - (( int ) myTotalScaleBarWidth ) - myMargin; myOriginY = myCanvasHeight - myMargin; break; default: QgsDebugMsg( "Unable to determine where to put scale bar so defaulting to top left" ); } //Set pen to draw with QPen myForegroundPen( mColor, 2 ); QPen myBackgroundPen( Qt::white, 4 ); //Cast myScaleBarWidth to int for drawing int myScaleBarWidthInt = ( int ) myScaleBarWidth; //Create array of vertices for scale bar depending on style switch ( mStyleIndex ) { case 0: // Tick Down { QPolygon myTickDownArray( 4 ); //draw a buffer first so bar shows up on dark images theQPainter->setPen( myBackgroundPen ); myTickDownArray.putPoints( 0, 4, myOriginX, myOriginY + myMajorTickSize, myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize ); theQPainter->drawPolyline( myTickDownArray ); //now draw the bar itself in user selected color theQPainter->setPen( myForegroundPen ); myTickDownArray.putPoints( 0, 4, myOriginX, myOriginY + myMajorTickSize, myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize ); theQPainter->drawPolyline( myTickDownArray ); break; } case 1: // tick up { QPolygon myTickUpArray( 4 ); //draw a buffer first so bar shows up on dark images theQPainter->setPen( myBackgroundPen ); myTickUpArray.putPoints( 0, 4, myOriginX, myOriginY, myOriginX, myOriginY + myMajorTickSize, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize, myScaleBarWidthInt + myOriginX, myOriginY ); theQPainter->drawPolyline( myTickUpArray ); //now draw the bar itself in user selected color theQPainter->setPen( myForegroundPen ); myTickUpArray.putPoints( 0, 4, myOriginX, myOriginY, myOriginX, myOriginY + myMajorTickSize, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize, myScaleBarWidthInt + myOriginX, myOriginY ); theQPainter->drawPolyline( myTickUpArray ); break; } case 2: // Bar { QPolygon myBarArray( 2 ); //draw a buffer first so bar shows up on dark images theQPainter->setPen( myBackgroundPen ); myBarArray.putPoints( 0, 2, myOriginX, myOriginY + ( myMajorTickSize / 2 ), myScaleBarWidthInt + myOriginX, myOriginY + ( myMajorTickSize / 2 ) ); theQPainter->drawPolyline( myBarArray ); //now draw the bar itself in user selected color theQPainter->setPen( myForegroundPen ); myBarArray.putPoints( 0, 2, myOriginX, myOriginY + ( myMajorTickSize / 2 ), myScaleBarWidthInt + myOriginX, myOriginY + ( myMajorTickSize / 2 ) ); theQPainter->drawPolyline( myBarArray ); break; } case 3: // box { // Want square corners for a box myBackgroundPen.setJoinStyle( Qt::MiterJoin ); myForegroundPen.setJoinStyle( Qt::MiterJoin ); QPolygon myBoxArray( 5 ); //draw a buffer first so bar shows up on dark images theQPainter->setPen( myBackgroundPen ); myBoxArray.putPoints( 0, 5, myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize, myOriginX, myOriginY + myMajorTickSize, myOriginX, myOriginY ); theQPainter->drawPolyline( myBoxArray ); //now draw the bar itself in user selected color theQPainter->setPen( myForegroundPen ); theQPainter->setBrush( QBrush( mColor, Qt::SolidPattern ) ); int midPointX = myScaleBarWidthInt / 2 + myOriginX; myBoxArray.putPoints( 0, 5, myOriginX, myOriginY, midPointX, myOriginY, midPointX, myOriginY + myMajorTickSize, myOriginX, myOriginY + myMajorTickSize, myOriginX, myOriginY ); theQPainter->drawPolygon( myBoxArray ); theQPainter->setBrush( Qt::NoBrush ); myBoxArray.putPoints( 0, 5, midPointX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY, myScaleBarWidthInt + myOriginX, myOriginY + myMajorTickSize, midPointX, myOriginY + myMajorTickSize, midPointX, myOriginY ); theQPainter->drawPolygon( myBoxArray ); break; } default: QgsDebugMsg( "Unknown style" ); } //Do actual drawing of scale bar // //Do drawing of scale bar text // QColor myBackColor = Qt::white; QColor myForeColor = Qt::black; //Draw the minimum label buffer theQPainter->setPen( myBackColor ); myFontWidth = myFontMetrics.width( "0" ); myFontHeight = myFontMetrics.height(); for ( int i = 0 - myBufferSize; i <= myBufferSize; i++ ) { for ( int j = 0 - myBufferSize; j <= myBufferSize; j++ ) { theQPainter->drawText( int( i + ( myOriginX - ( myFontWidth / 2 ) ) ), int( j + ( myOriginY - ( myFontHeight / 4 ) ) ), "0" ); } } //Draw minimum label theQPainter->setPen( myForeColor ); theQPainter->drawText( int( myOriginX - ( myFontWidth / 2 ) ), int( myOriginY - ( myFontHeight / 4 ) ), "0" ); // //Draw maximum label // theQPainter->setPen( myBackColor ); myFontWidth = myFontMetrics.width( myScaleBarMaxLabel ); myFontHeight = myFontMetrics.height(); //first the buffer for ( int i = 0 - myBufferSize; i <= myBufferSize; i++ ) { for ( int j = 0 - myBufferSize; j <= myBufferSize; j++ ) { theQPainter->drawText( int( i + ( myOriginX + myScaleBarWidthInt - ( myFontWidth / 2 ) ) ), int( j + ( myOriginY - ( myFontHeight / 4 ) ) ), myScaleBarMaxLabel ); } } //then the text itself theQPainter->setPen( myForeColor ); theQPainter->drawText( int( myOriginX + myScaleBarWidthInt - ( myFontWidth / 2 ) ), int( myOriginY - ( myFontHeight / 4 ) ), myScaleBarMaxLabel ); // //Draw unit label // theQPainter->setPen( myBackColor ); //first the buffer for ( int i = 0 - myBufferSize; i <= myBufferSize; i++ ) { for ( int j = 0 - myBufferSize; j <= myBufferSize; j++ ) { theQPainter->drawText( i + ( myOriginX + myScaleBarWidthInt + myTextOffsetX ), j + ( myOriginY + myMajorTickSize ), myScaleBarUnitLabel ); } } //then the text itself theQPainter->setPen( myForeColor ); theQPainter->drawText( ( myOriginX + myScaleBarWidthInt + myTextOffsetX ), ( myOriginY + myMajorTickSize ), myScaleBarUnitLabel ); } }
/*! \brief Calculate minor/medium ticks for major ticks \param majorTicks Major ticks \param maxMinorSteps Maximum number of minor steps \param stepSize Step size \param minorTicks Array to be filled with the calculated minor ticks \param mediumTicks Array to be filled with the calculated medium ticks */ void QwtLogScaleEngine::buildMinorTicks( const QList<double> &majorTicks, int maxMinorSteps, double stepSize, QList<double> &minorTicks, QList<double> &mediumTicks ) const { const double logBase = base(); if ( stepSize < 1.1 ) // major step width is one base { double minStep = divideInterval( stepSize, maxMinorSteps + 1 ); if ( minStep == 0.0 ) return; const int numSteps = qRound( stepSize / minStep ); int mediumTickIndex = -1; if ( ( numSteps > 2 ) && ( numSteps % 2 == 0 ) ) mediumTickIndex = numSteps / 2; for ( int i = 0; i < majorTicks.count() - 1; i++ ) { const double v = majorTicks[i]; const double s = logBase / numSteps; if ( s >= 1.0 ) { for ( int j = 2; j < numSteps; j++ ) { minorTicks += v * j * s; } } else { for ( int j = 1; j < numSteps; j++ ) { const double tick = v + j * v * ( logBase - 1 ) / numSteps; if ( j == mediumTickIndex ) mediumTicks += tick; else minorTicks += tick; } } } } else { double minStep = divideInterval( stepSize, maxMinorSteps ); if ( minStep == 0.0 ) return; if ( minStep < 1.0 ) minStep = 1.0; // # subticks per interval int numTicks = qRound( stepSize / minStep ) - 1; // Do the minor steps fit into the interval? if ( qwtFuzzyCompare( ( numTicks + 1 ) * minStep, stepSize, stepSize ) > 0 ) { numTicks = 0; } if ( numTicks < 1 ) return; int mediumTickIndex = -1; if ( ( numTicks > 2 ) && ( numTicks % 2 ) ) mediumTickIndex = numTicks / 2; // substep factor = base^substeps const qreal minFactor = qMax( qPow( logBase, minStep ), qreal( logBase ) ); for ( int i = 0; i < majorTicks.count(); i++ ) { double tick = majorTicks[i]; for ( int j = 0; j < numTicks; j++ ) { tick *= minFactor; if ( j == mediumTickIndex ) mediumTicks += tick; else minorTicks += tick; } } } }
void ColorInspector::onModeChanged() { // assume hsv if not checked bool newValue = ui->rgbButton->isChecked(); QSettings settings(PENCIL2D, PENCIL2D); settings.setValue("isRgb", newValue); isRgbColors = newValue; if (isRgbColors) { // Spinboxes may emit unwanted valueChanged signals when setting ranges // so block them all first QSignalBlocker b1(ui->RedspinBox); QSignalBlocker b2(ui->GreenspinBox); QSignalBlocker b3(ui->BluespinBox); QSignalBlocker b4(ui->AlphaspinBox); ui->red->setText("R"); ui->green->setText("G"); ui->blue->setText("B"); ui->alpha->setText("A"); ui->RedspinBox->setRange(0,255); ui->RedspinBox->setSuffix(""); ui->GreenspinBox->setRange(0,255); ui->GreenspinBox->setSuffix(""); ui->BluespinBox->setRange(0,255); ui->BluespinBox->setSuffix(""); ui->AlphaspinBox->setRange(0,255); ui->AlphaspinBox->setSuffix(""); mCurrentColor = mCurrentColor.toRgb(); ui->red_slider->setMax(255); ui->red_slider->setColorType(ColorSlider::ColorType::RED); ui->red_slider->setColorSpecType(ColorSlider::ColorSpecType::RGB); ui->green_slider->setColorSpecType(ColorSlider::ColorSpecType::RGB); ui->green_slider->setColorType(ColorSlider::ColorType::GREEN); ui->blue_slider->setColorSpecType(ColorSlider::ColorSpecType::RGB); ui->blue_slider->setColorType(ColorSlider::ColorType::BLUE); ui->alpha_slider->setColorSpecType(ColorSlider::ColorSpecType::RGB); ui->alpha_slider->setColorType(ColorSlider::ColorType::ALPHA); ui->RedspinBox->setValue(mCurrentColor.red()); ui->GreenspinBox->setValue(mCurrentColor.green()); ui->BluespinBox->setValue(mCurrentColor.blue()); ui->AlphaspinBox->setValue(mCurrentColor.alpha()); } else { QSignalBlocker b1(ui->RedspinBox); QSignalBlocker b2(ui->GreenspinBox); QSignalBlocker b3(ui->BluespinBox); QSignalBlocker b4(ui->AlphaspinBox); ui->red->setText("H"); ui->green->setText("S"); ui->blue->setText("V"); ui->alpha->setText("A"); ui->red_slider->setMax(359); ui->red_slider->setColorType(ColorSlider::ColorType::HUE); ui->red_slider->setColorSpecType(ColorSlider::ColorSpecType::HSV); ui->green_slider->setColorType(ColorSlider::ColorType::SAT); ui->green_slider->setColorSpecType(ColorSlider::ColorSpecType::HSV); ui->blue_slider->setColorType(ColorSlider::ColorType::VAL); ui->blue_slider->setColorSpecType(ColorSlider::ColorSpecType::HSV); ui->alpha_slider->setColorType(ColorSlider::ColorType::ALPHA); ui->alpha_slider->setColorSpecType(ColorSlider::ColorSpecType::HSV); ui->RedspinBox->setRange(0,359); ui->RedspinBox->setSuffix("°"); ui->GreenspinBox->setRange(0,100); ui->GreenspinBox->setSuffix("%"); ui->BluespinBox->setRange(0,100); ui->BluespinBox->setSuffix("%"); ui->AlphaspinBox->setRange(0,100); ui->AlphaspinBox->setSuffix("%"); mCurrentColor = mCurrentColor.toHsv(); const qreal bound = 100.0 / 255.0; // from 255 to 100 ui->RedspinBox->setValue(mCurrentColor.hsvHue()); ui->GreenspinBox->setValue(qRound(mCurrentColor.hsvSaturation()*bound)); ui->BluespinBox->setValue(qRound(mCurrentColor.value()*bound)); ui->AlphaspinBox->setValue(qRound(mCurrentColor.alpha()*bound)); } emit modeChange(isRgbColors); }
void Dlg_Physics::UpdateUI(void) { CVX_Environment* ptEnv = pSim->pEnv; //pointer to current environment object bool EqMode = pSim->IsEquilibriumEnabled(); // TimestepMag = pSim->dt/pSim->DtFrac; //Sim if (!pSim->Paused && pSim->Running) SetStatusButtonText(true); else SetStatusButtonText(false); ui.RecordButton->setChecked(pSim->Recording); ui.UseEquilibriumCheck->setChecked(pSim->IsEquilibriumEnabled()); StopCondition CurStopCond = pSim->GetStopConditionType(); ui.StopSelectCombo->setCurrentIndex(CurStopCond); ui.StopValueEdit->setEnabled(CurStopCond != SC_NONE); ui.StopValueEdit->setText(QString::number(pSim->GetStopConditionValue())); switch (CurStopCond){ case SC_NONE: ui.StopValueLabel->setText(""); break; case SC_MAX_TIME_STEPS: ui.StopValueLabel->setText("#"); break; case SC_MAX_SIM_TIME: ui.StopValueLabel->setText("Sec"); break; case SC_TEMP_CYCLES: ui.StopValueLabel->setText("#"); break; case SC_CONST_MAXENERGY: ui.StopValueLabel->setText("Avg mJ/Vox/500 ts"); break; case SC_MIN_KE: ui.StopValueLabel->setText("Avg mJ/Vox/500 ts"); break; case SC_MIN_MAXMOVE: ui.StopValueLabel->setText("Max mm/timestep"); break; } ui.dtSlider->setRange(0, 1000); ui.dtSlider->setValue(qRound(pSim->DtFrac*500)); ui.dtEdit->setText(QString::number(pSim->DtFrac, 'g', 3)); ui.BondDampSlider->setEnabled(!EqMode); ui.BondDampEdit->setEnabled(!EqMode); ui.BondDampSlider->setRange(0, 100); ui.BondDampSlider->setValue(qRound(pSim->GetBondDampZ()*50)); ui.BondDampEdit->setText(QString::number(pSim->GetBondDampZ(), 'g', 3)); //from .00001 to .1 ui.GNDDampSlider->setEnabled(!EqMode); ui.GNDDampEdit->setEnabled(!EqMode); ui.GNDDampSlider->setRange(0, 100); if (pSim->GetSlowDampZ() == 0) ui.GNDDampSlider->setValue(0); else ui.GNDDampSlider->setValue(qRound((log10(pSim->GetSlowDampZ())+5)*25.0)); ui.GNDDampEdit->setText(QString::number(pSim->GetSlowDampZ(), 'g', 3)); ui.UseSelfColCheck->setChecked(pSim->IsSelfColEnabled()); ui.ColDampSlider->setEnabled(pSim->IsSelfColEnabled()); ui.ColDampSlider->setRange(0, 100); ui.ColDampSlider->setValue(qRound(pSim->GetCollisionDampZ()*50)); ui.ColDampEdit->setText(QString::number(pSim->GetCollisionDampZ(), 'g', 3)); ui.UseMaxVelLimitCheck->setEnabled(!EqMode); ui.MaxVelLimitSlider->setEnabled(!EqMode); ui.UseMaxVelLimitCheck->setChecked(pSim->IsMaxVelLimitEnabled()); ui.MaxVelLimitSlider->setEnabled(pSim->IsMaxVelLimitEnabled()); ui.MaxVelLimitSlider->setRange(0, 100); ui.MaxVelLimitSlider->setValue(qRound(pSim->GetMaxVoxVelLimit()*400)); //Env ui.UseTempCheck->setChecked(ptEnv->IsTempEnabled()); ui.TempSlider->setRange(0, 50); //+/- 25 degrees from TempBase ui.TempSlider->setValue(qRound(25 + ptEnv->GetTempAmplitude())); ui.TempEdit->setText(QString::number(ptEnv->GetTempBase() + ptEnv->GetTempAmplitude(), 'g', 3)); ui.Temp2Slider->setRange(0, 50); //+/- 25 degrees from TempBase ui.Temp2Slider->setValue(qRound(25 + ptEnv->GetTemp2Amplitude())); ui.Temp2Edit->setText(QString::number(ptEnv->GetTempBase() + ptEnv->GetTemp2Amplitude(), 'g', 3)); ui.VaryTempCheck->setChecked(ptEnv->IsTempVaryEnabled()); ui.TempPerSlider->setRange(0, 10000); ui.TempPerSlider->setValue(qRound(ptEnv->GetTempPeriod()/pSim->OptimalDt)); //slider range of 0-10,000 timesteps ui.TempPerEdit->setText(QString::number(ptEnv->GetTempPeriod(), 'g', 3)); ui.UseGravCheck->setChecked(ptEnv->IsGravityEnabled()); ui.GravSlider->setRange(0, 10000); ui.GravSlider->setValue(qRound(-ptEnv->GetGravityAccel()/0.00981)); //1e-5 takes care for float -> int rounding... ui.GravEdit->setText(QString::number(ptEnv->GetGravityAccel(), 'g', 3)); ui.UseFloorCheck->setChecked(ptEnv->IsFloorEnabled()); // ui.SurfMeshCheck->setEnabled(false); // if (pSim->SurfMesh.DefMesh.Exists()) ui.SurfMeshCheck->setEnabled(true); //View bool ViewEnabled = true; switch (pSim->GetCurViewMode()){ case RVM_NONE: ui.DispDisableRadio->setChecked(true); ViewEnabled = false; break; case RVM_VOXELS: ui.DispVoxelsRadio->setChecked(true); break; case RVM_BONDS: ui.DispConnRadio->setChecked(true); break; } ui.ViewOptionsGroup->setEnabled(ViewEnabled); ui.ColorGroup->setEnabled(ViewEnabled); ui.CoMCheck->setEnabled(ViewEnabled); // ui.BbCheck->setEnabled(ViewEnabled); switch (pSim->GetCurViewVox()){ case RVV_DISCRETE: ui.ViewDiscreteRadio->setChecked(true); break; case RVV_DEFORMED: ui.ViewDeformedRadio->setChecked(true); break; case RVV_SMOOTH: ui.ViewSmoothRadio->setChecked(true); break; } ui.ForcesCheck->setChecked(pSim->ViewForce); ui.LocalCoordCheck->setChecked(pSim->ViewAngles); switch (pSim->GetCurViewCol()){ case RVC_TYPE: ui.TypeRadio->setChecked(true); break; case RVC_KINETIC_EN: ui.KineticERadio->setChecked(true); break; case RVC_DISP: ui.DisplacementRadio->setChecked(true); break; case RVC_STATE: ui.StateRadio->setChecked(true); break; case RVC_STRAIN_EN: ui.StrainERadio->setChecked(true); break; case RVC_STRAIN: ui.StrainRadio->setChecked(true); break; case RVC_STRESS: ui.StressRadio->setChecked(true); break; } ui.CoMCheck->setChecked(pSim->LockCoMToCenter); // ui.BbCheck->setChecked(pSim->HideBoundingBox); ui.VariableCombo->setCurrentIndex(CurPlotType); ui.DirectionCombo->setCurrentIndex(CurPlotDir); }
void US_MPI_Analysis::dmga_worker_loop( void ) { // Initialize genes dgenes.clear(); population = parameters[ "population" ].toInt(); // Build the first generation of genes for ( int ii = 0; ii < population; ii++ ) { dgenes << new_dmga_gene(); } fitness.reserve( population ); Fitness empty_fitness; empty_fitness.fitness = LARGE; for ( int ii = 0; ii < population; ii++ ) { empty_fitness.index = ii; fitness << empty_fitness; } int generations = parameters[ "generations" ].toInt(); int crossover = parameters[ "crossover" ].toInt(); int mutation = parameters[ "mutation" ].toInt(); int plague = parameters[ "plague" ].toInt(); int elitism = parameters[ "elitism" ].toInt(); int p_mutate = mutation; int p_crossover = p_mutate + crossover; int p_plague = p_crossover + plague; int grp_nbr = my_rank / gcores_count; int deme_nbr = my_rank - grp_nbr * gcores_count; fitness_map.clear(); fitness_count = 0; fitness_hits = 0; max_rss(); QDateTime start = QDateTime::currentDateTime(); MPI_GA_MSG msg; for ( generation = 0; generation < generations; generation++ ) { max_rss(); DbTimMsg("Worker start rank/generation/elapsed-secs"); // Calculate fitness for ( int ii = 0; ii < population; ii++ ) { fitness[ ii ].index = ii; fitness[ ii ].fitness = get_fitness_dmga( dgenes[ ii ] ); DbgLv(1) << my_rank << "dg:getf: ii" << ii << " fitness" << fitness[ii].fitness; } // Sort fitness qSort( fitness ); DbTimMsg("Worker after get_fitness loop + sort"); // Refine with gradient search method (gsm) on last generation if ( generation == generations - 1 ) { DbgLv(DL) << "Deme" << grp_nbr << deme_nbr << ": At last generation minimize."; DbTimMsg("Worker before gsm rank/generation/elapsed"); in_gsm = true; fitness[ 0 ].fitness = minimize_dmga( dgenes[ fitness[ 0 ].index ], fitness[ 0 ].fitness ); DbgLv(DL) << "Deme" << grp_nbr << deme_nbr << ": last generation minimize fitness=" << fitness[0].fitness; DbTimMsg("Worker after gsm rank/generation/elapsed"); in_gsm = false; } max_rss(); // Send best gene to master if((deme_nbr%10)==1) { DbgLv(1) << "Best gene to master: gen" << generation << "worker" << deme_nbr << "fitness" << fitness[0].fitness; dump_fitness( fitness ); } msg.generation = generation; dgene = dgenes[ fitness[ 0 ].index ]; marker_from_dgene( dgmarker, dgene ); msg.size = nfloatc; msg.fitness = fitness[ 0 ].fitness; MPI_Send( &msg, // to MPI #1 sizeof( msg ), MPI_BYTE, MPI_Job::MASTER, GENERATION, my_communicator ); MPI_Send( dgmarker.data(), // to MPI #2 nfloatc, MPI_DOUBLE, MPI_Job::MASTER, GENE, my_communicator ); DbTimMsg("Worker after send fitness,genes"); // Receive instructions from master (continue or finish) MPI_Status status; MPI_Recv( &msg, // from MPI #3 sizeof( msg ), MPI_BYTE, MPI_ANY_SOURCE, MPI_ANY_TAG, my_communicator, &status ); DbTimMsg("Worker after receive instructions"); max_rss(); if ( status.MPI_TAG == FINISHED ) { DbgLv(0) << "Deme" << grp_nbr << deme_nbr << ": Finish signalled at deme generation" << generation + 1; break; } // See if we are really done if ( generation == generations - 1 ) { DbgLv(0) << "Deme" << grp_nbr << deme_nbr << ": At last generation"; continue; } // Mark duplicate genes int f0 = 0; // An index into the fitness array int f1 = 1; // A second index // The value of 1.0e-8 for close fitness is arbitrary. Parameterize? const double NEAR_MATCH = 1.0e-8; const double EPSF_SCALE = 1.0e-3; double fitpwr = (double)qRound( log10( fitness[ 0 ].fitness ) ); double epsilon_f = pow( 10.0, fitpwr ) * EPSF_SCALE; DbgLv(1) << "gw:" << my_rank << ": Dup best-gene clean: fitness0 fitpwr epsilon_f" << fitness[0].fitness << fitpwr << epsilon_f; while ( f1 < population ) { double fitdiff = qAbs( fitness[ f0 ].fitness - fitness[ f1 ].fitness ); if ( fitdiff < epsilon_f ) { bool match = true; int g0 = fitness[ f0 ].index; int g1 = fitness[ f1 ].index; DGene gene0 = dgenes[ g0 ]; DGene gene1 = dgenes[ g1 ]; for ( int ii = 0; ii < nfloatc; ii++ ) { double val0; double val1; US_dmGA_Constraints::AttribType atype = cns_flt[ ii ].atype; int mcompx = cns_flt[ ii ].mcompx; fetch_attr_value( val0, gene0, atype, mcompx ); fetch_attr_value( val1, gene1, atype, mcompx ); double difv = qAbs( ( val0 - val1 ) / val0 ); if ( difv > NEAR_MATCH ) { DbgLv(1) << "gw:" << my_rank << ": Dup NOT cleaned: f0 f1 fit0 fit1" << f0 << f1 << fitness[f0].fitness << fitness[f1].fitness << "ii g0 g1 g0v g1v" << ii << g0 << g1 << val0 << val1; match = false; f0 = f1; break; } } if ( match ) { DbgLv(1) << "gw:" << my_rank << ": Dup cleaned: f0 f1 fit0 fit1" << f0 << f1 << fitness[f0].fitness << fitness[f1].fitness; fitness[ f1 ].fitness = LARGE; // Invalidate gene/sim_values } } else f0 = f1; f1++; } // Re-sort qSort( fitness ); DbgLv(1) << "gw:" << my_rank << ": fitness sorted"; QList< DGene > old_genes = dgenes; int gener_save = generation; if ( generation > 0 && ( generation % g_redo_inc ) == 0 ) { // Set up to re-do initial genes after minimization double fit0 = fitness[ 0 ].fitness; fitness[ 0 ].fitness = minimize_dmga( dgenes[ fitness[ 0 ].index ], fitness[ 0 ].fitness ); double fit1 = fitness[ 0 ].fitness; dgene = dgenes[ fitness[ 0 ].index ]; old_genes[0] = dgene; double aval; int nlim = 0; for ( int ii = 0; ii < nfloatc; ii++ ) { // Insure all the new gene attribute values are inside range US_dmGA_Constraints::AttribType atype = cns_flt[ ii ].atype; int mcompx = cns_flt[ ii ].mcompx; double vmin = cns_flt[ ii ].low; double vmax = cns_flt[ ii ].high; fetch_attr_value( aval, dgene, atype, mcompx ); if ( aval < vmin || aval > vmax ) { if((group_rank%10)==1) DbgLv(0) << "gw:" << my_rank << ": re-do : ii" << ii << "aval vmin vmax" << aval << vmin << vmax; aval = qMax( vmin, qMin( vmax, aval ) ); store_attr_value( aval, dgene, atype, mcompx ); nlim++; } } if ( nlim > 0 ) { // If adjustments due to limits, recompute fitness fit1 = get_fitness_dmga( dgene ); if((group_rank%10)==1) DbgLv(0) << "gw:" << my_rank << ": re-do : fit1a fit1b" << fitness[ 0 ].fitness << fit1; fitness[ 0 ].fitness = fit1; } p_mutate = p_plague; for ( int gg = 0; gg < population; gg++ ) old_genes[ gg ] = dgene; if((group_rank%10)==1) DbgLv(0) << "gw:" << my_rank << ": re-do genes at gen" << generation << "gen fitness" << fit0 << "post-min fitness" << fit1; generation = 0; } // Create new generation from old // First copy elite genes for ( int gg = 0; gg < elitism; gg++ ) dgenes[ gg ] = old_genes[ fitness[ gg ].index ]; DbgLv(1) << "gw:" << my_rank << ": elites copied"; int immigr_count = migrate_dgenes(); DbgLv(1) << "gw:" << my_rank << ": immigr_count" << immigr_count << "dgenes,old sizes" << dgenes.size() << old_genes.size() << population; DbTimMsg("Worker before elitism loop"); for ( int gg = elitism + immigr_count; gg < population; gg++ ) { // Select a random gene from old population using exponential // distribution int gene_index = e_random(); int probability = u_random( p_plague ); DbgLv(1) << "gw:" << my_rank << ": gg" << gg << "gene_index" << gene_index << "probability" << probability; dgene = old_genes[ gene_index ]; // Do a self-mutate on some genes if ( probability < p_mutate ) mutate_dgene( dgene ); // Do cross-mutation on some other genes else if ( probability < p_crossover ) cross_dgene ( dgene, old_genes ); // Purge the remainder (replace with new gene) else dgene = new_dmga_gene(); dgenes[ gg ] = dgene; } DbTimMsg("Worker after elitism loop"); generation = gener_save; p_mutate = mutation; max_rss(); } // End of generation loop DbTimMsg(" +++Worker after generation loop"); }
//------------------------------------------------------------------- void SkewTWindow::saveFileSYLK (SylkFile &slk) { int lig, col; lig = 1; slk.addCell (lig++, 1, "XyGrib - SkewT data"); if (! skewt) { slk.addCell (lig++, 1, "No data"); return; } Sounding * snd = skewt->getSounding (); if (! snd) { slk.addCell (lig++, 1, "No data"); return; } //------------------------------- slk.addCell (lig, 1, "Location"); slk.addCell (lig, 2, skewt->location); lig ++; slk.addCell (lig, 1, "Data center"); slk.addCell (lig, 2, skewt->datacenter); lig ++; slk.addCell (lig, 1, "Reference date"); slk.addCell (lig, 2, Util::formatDateTimeShort(skewt->dateref)); lig ++; slk.addCell (lig, 1, "Current date"); slk.addCell (lig, 2, Util::formatDateTimeShort(skewt->date)); lig ++; //------------------------------- // Indices LI, SI, KI, TT, SWEAT, CAPE, CIN lig++; slk.addCell (lig, 1, "LI"); if (GribDataIsDef(snd->LI)) slk.addCell (lig, 2, qRound(snd->LI)); lig++; slk.addCell (lig, 1, "SI"); if (GribDataIsDef(snd->SI)) slk.addCell (lig, 2, qRound(snd->SI)); lig++; slk.addCell (lig, 1, "KI"); if (GribDataIsDef(snd->KI)) slk.addCell (lig, 2, qRound(snd->KI)); lig++; slk.addCell (lig, 1, "TT"); if (GribDataIsDef(snd->TT)) slk.addCell (lig, 2, qRound(snd->TT)); lig++; slk.addCell (lig, 1, "SWEAT"); if (GribDataIsDef(snd->SWEAT)) slk.addCell (lig, 2, qRound(snd->SWEAT)); lig++; slk.addCell (lig, 1, "CAPE"); if (GribDataIsDef(snd->CAPE)) slk.addCell (lig, 2, qRound(snd->CAPE)); lig++; slk.addCell (lig, 1, "CIN"); if (GribDataIsDef(snd->CIN)) slk.addCell (lig, 2, qRound(snd->CIN)); lig++; lig++; //------------------------------- // Altitude data QList <SoundingPoint> *allpts = snd->getAllSounds(); QList <SoundingPointWind> *allwinds = snd->getAllSoundsWind(); QList <double> allAlts; for (const auto & allpt : *allpts) { if (allpt.ok() && !allAlts.contains(allpt.hpa)) allAlts << allpt.hpa; } for (const auto & allwind : *allwinds) { if (allwind.ok() && !allAlts.contains(allwind.hpa)) allAlts << allwind.hpa; } qSort (allAlts); col = 1; slk.addCell (lig, col++, "Altitude (hPa)"); slk.addCell (lig, col++, tr("Temperature")+" ("+Util::getDataUnit(GRB_TEMP)+")"); slk.addCell (lig, col++, tr("Dew point")+" ("+Util::getDataUnit(GRB_TEMP)+")"); slk.addCell (lig, col++, tr("Wind speed")+" ("+Util::getDataUnit(GRB_WIND_SPEED)+")"); slk.addCell (lig, col++, tr("Wind direction")+" ("+Util::getDataUnit(GRB_WIND_DIR)+")"); for (double alt : allAlts) { lig ++; col = 1; slk.addCell (lig, col++, alt); double v; SoundingPointWind w; v = snd->getTempCByAlt (alt); if (GribDataIsDef(v)) slk.addCell (lig, col, Util::formatTemperature(v+273.15,false).toDouble()); col ++; v = snd->getDewpCByAlt (alt); if (GribDataIsDef(v)) slk.addCell (lig, col, Util::formatTemperature(v+273.15,false).toDouble()); col ++; w = snd->getWindByAlt (alt); if (w.ok()) slk.addCell (lig, col, Util::formatSpeed_Wind (w.speedMs(),false).toDouble()); col ++; if (w.ok()) slk.addCell (lig, col, qRound(w.degrees())); col ++; } }
/*! Draw a tick \param painter Painter \param value Value of the tick \param len Length of the tick \sa drawBackbone(), drawLabel() */ void QwtScaleDraw::drawTick( QPainter *painter, double value, double len ) const { if ( len <= 0 ) return; const bool roundingAlignment = QwtPainter::roundingAlignment( painter ); QPointF pos = d_data->pos; double tval = scaleMap().transform( value ); if ( roundingAlignment ) tval = qRound( tval ); const int pw = penWidth(); int a = 0; if ( pw > 1 && roundingAlignment ) a = 1; switch ( alignment() ) { case LeftScale: { double x1 = pos.x() + a; double x2 = pos.x() + a - pw - len; if ( roundingAlignment ) { x1 = qRound( x1 ); x2 = qRound( x2 ); } QwtPainter::drawLine( painter, x1, tval, x2, tval ); break; } case RightScale: { double x1 = pos.x(); double x2 = pos.x() + pw + len; if ( roundingAlignment ) { x1 = qRound( x1 ); x2 = qRound( x2 ); } QwtPainter::drawLine( painter, x1, tval, x2, tval ); break; } case BottomScale: { double y1 = pos.y(); double y2 = pos.y() + pw + len; if ( roundingAlignment ) { y1 = qRound( y1 ); y2 = qRound( y2 ); } QwtPainter::drawLine( painter, tval, y1, tval, y2 ); break; } case TopScale: { double y1 = pos.y() + a; double y2 = pos.y() - pw - len + a; if ( roundingAlignment ) { y1 = qRound( y1 ); y2 = qRound( y2 ); } QwtPainter::drawLine( painter, tval, y1, tval, y2 ); break; } } }
/*! Draws the baseline of the scale \param painter Painter \sa drawTick(), drawLabel() */ void QwtScaleDraw::drawBackbone( QPainter *painter ) const { const bool doAlign = QwtPainter::roundingAlignment( painter ); const QPointF &pos = d_data->pos; const double len = d_data->len; const int pw = qMax( penWidth(), 1 ); // pos indicates a border not the center of the backbone line // so we need to shift its position depending on the pen width // and the alignment of the scale double off; if ( doAlign ) { if ( alignment() == LeftScale || alignment() == TopScale ) off = ( pw - 1 ) / 2; else off = pw / 2; } else { off = 0.5 * penWidth(); } switch ( alignment() ) { case LeftScale: { double x = pos.x() - off; if ( doAlign ) x = qRound( x ); QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + len ); break; } case RightScale: { double x = pos.x() + off; if ( doAlign ) x = qRound( x ); QwtPainter::drawLine( painter, x, pos.y(), x, pos.y() + len ); break; } case TopScale: { double y = pos.y() - off; if ( doAlign ) y = qRound( y ); QwtPainter::drawLine( painter, pos.x(), y, pos.x() + len, y ); break; } case BottomScale: { double y = pos.y() + off; if ( doAlign ) y = qRound( y ); QwtPainter::drawLine( painter, pos.x(), y, pos.x() + len, y ); break; } } }
bool SizeFitter::fitIt(QSize size, QSize &fittedSize, QRect *clippedRect) const { float scaleFactor; bool result; QSize orientedTargetSize = getOrientedTargetSize(size); // enlarge? if (!isFitOptionEnabled(Enlarge) && size.width() <= orientedTargetSize.width() && size.height() <= orientedTargetSize.height()) { fittedSize = size; if (clippedRect != 0) { clippedRect->setTopLeft(QPoint(0, 0)); clippedRect->setSize(fittedSize); } return false; } result = false; if (size.width() > size.height()) { // landscape scaleFactor = (float)orientedTargetSize.width() / (float)size.width(); fittedSize.setWidth(qRound(size.width() * scaleFactor)); fittedSize.setHeight(qRound(size.height() * scaleFactor)); if (scaleFactor != 1.0f) { result = true; } // the new height might still be too large... if (fittedSize.height() > orientedTargetSize.height()) { // ...so scale again scaleFactor = (float)orientedTargetSize.height() / (float)fittedSize.height(); fittedSize.setWidth (qRound(fittedSize.width() * scaleFactor)); fittedSize.setHeight(qRound(fittedSize.height() * scaleFactor)); if (scaleFactor != 1.0f) { result = true ; } } } else { // portrait scaleFactor = (float)orientedTargetSize.height() / (float)size.height(); fittedSize.setWidth (qRound(size.width() * scaleFactor)); fittedSize.setHeight (qRound(size.height() * scaleFactor)); if (scaleFactor != 1.0f) { result = true; } // the new width might still be too large... if (fittedSize.width() > orientedTargetSize.width()) { // ...so scale again scaleFactor = (float)orientedTargetSize.width() / (float)fittedSize.width(); fittedSize.setWidth (qRound(fittedSize.width() * scaleFactor)); fittedSize.setHeight (qRound(fittedSize.height() * scaleFactor)); if (scaleFactor != 1.0f) { result = true ; } } } if (clippedRect != 0) { // no clipping, select entire image clippedRect->setTopLeft(QPoint(0, 0)); clippedRect->setSize(size); } return result; }
/*! \brief Determine the minimum border distance This member function returns the minimum space needed to draw the mark labels at the scale's endpoints. \param font Font \param start Start border distance \param end End border distance */ void QwtScaleDraw::getBorderDistHint( const QFont &font, int &start, int &end ) const { start = 0; end = 1.0; if ( !hasComponent( QwtAbstractScaleDraw::Labels ) ) return; const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick ); if ( ticks.count() == 0 ) return; // Find the ticks, that are mapped to the borders. // minTick is the tick, that is mapped to the top/left-most position // in widget coordinates. double minTick = ticks[0]; double minPos = scaleMap().transform( minTick ); double maxTick = minTick; double maxPos = minPos; for ( int i = 1; i < ticks.count(); i++ ) { const double tickPos = scaleMap().transform( ticks[i] ); if ( tickPos < minPos ) { minTick = ticks[i]; minPos = tickPos; } if ( tickPos > scaleMap().transform( maxTick ) ) { maxTick = ticks[i]; maxPos = tickPos; } } double e = 0.0; double s = 0.0; if ( orientation() == Qt::Vertical ) { s = -labelRect( font, minTick ).top(); s -= qAbs( minPos - qRound( scaleMap().p2() ) ); e = labelRect( font, maxTick ).bottom(); e -= qAbs( maxPos - scaleMap().p1() ); } else { s = -labelRect( font, minTick ).left(); s -= qAbs( minPos - scaleMap().p1() ); e = labelRect( font, maxTick ).right(); e -= qAbs( maxPos - scaleMap().p2() ); } if ( s < 0.0 ) s = 0.0; if ( e < 0.0 ) e = 0.0; start = qCeil( s ); end = qCeil( e ); }
void RenderStatistics::updateStats() { static QTime time; static int frames; static int lastTime; if (frames == 0) { time.start(); } else { int elapsed = time.elapsed(); timesPerFrames.append(elapsed - lastTime); lastTime = elapsed; if (elapsed > 5000) { qreal avgtime = elapsed / (qreal) frames; qreal var = 0; for (int i = 0; i < timesPerFrames.size(); ++i) { qreal diff = timesPerFrames.at(i) - avgtime; var += diff * diff; } var /= timesPerFrames.size(); qDebug("Average time per frame: %f ms (%i fps), std.dev: %f ms", avgtime, qRound(1000. / avgtime), qSqrt(var)); timePerFrame.append(avgtime); timesPerFrames.clear(); time.start(); lastTime = 0; frames = 0; } } ++frames; }
int Controller::countDialogsWidthFromRatio(int bodyWidth) const { auto result = qRound(bodyWidth * Auth().settings().dialogsWidthRatio()); accumulate_max(result, st::columnMinimalWidthLeft); // accumulate_min(result, st::columnMaximalWidthLeft); return result; }
void QSGTextMaskMaterialData::updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect) { Q_ASSERT(oldEffect == 0 || newEffect->type() == oldEffect->type()); QSGTextMaskMaterial *material = static_cast<QSGTextMaskMaterial *>(newEffect); QSGTextMaskMaterial *oldMaterial = static_cast<QSGTextMaskMaterial *>(oldEffect); if (oldMaterial == 0 || material->color() != oldMaterial->color() || state.isOpacityDirty()) { QColor c = material->color(); QVector4D color(c.redF(), c.greenF(), c.blueF(), c.alphaF()); color *= state.opacity(); program()->setUniformValue(m_color_id, color); if (oldMaterial == 0 || material->color() != oldMaterial->color()) { state.context()->functions()->glBlendColor(c.redF(), c.greenF(), c.blueF(), c.alphaF()); } } bool updated = material->ensureUpToDate(); Q_ASSERT(material->texture()); Q_ASSERT(oldMaterial == 0 || oldMaterial->texture()); if (updated || oldMaterial == 0 || oldMaterial->texture()->textureId() != material->texture()->textureId()) { program()->setUniformValue(m_textureScale_id, QVector2D(1.0 / material->cacheTextureWidth(), 1.0 / material->cacheTextureHeight())); glBindTexture(GL_TEXTURE_2D, material->texture()->textureId()); // Set the mag/min filters to be nearest. We only need to do this when the texture // has been recreated. if (updated) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } } if (state.isMatrixDirty()) { QMatrix4x4 transform = state.modelViewMatrix(); qreal xTranslation = transform(0, 3); qreal yTranslation = transform(1, 3); // Remove translation and check identity to see if matrix is only translating. // If it is, we can round the translation to make sure the text is pixel aligned, // which is the only thing that works with GL_NEAREST filtering. Adding rotations // and scales to native rendered text is not a prioritized use case, since the // default rendering type is designed for that. transform(0, 3) = 0.0; transform(1, 3) = 0.0; if (transform.isIdentity()) { transform(0, 3) = qRound(xTranslation); transform(1, 3) = qRound(yTranslation); transform = state.projectionMatrix() * transform; program()->setUniformValue(m_matrix_id, transform); } else { program()->setUniformValue(m_matrix_id, state.combinedMatrix()); } } }
void QSGTextMaskMaterial::populate(const QPointF &p, const QVector<quint32> &glyphIndexes, const QVector<QPointF> &glyphPositions, QSGGeometry *geometry, QRectF *boundingRect, QPointF *baseLine, const QMargins &margins) { Q_ASSERT(m_font.isValid()); QVector<QFixedPoint> fixedPointPositions; for (int i=0; i<glyphPositions.size(); ++i) fixedPointPositions.append(QFixedPoint::fromPointF(glyphPositions.at(i))); QTextureGlyphCache *cache = glyphCache(); QRawFontPrivate *fontD = QRawFontPrivate::get(m_font); cache->populate(fontD->fontEngine, glyphIndexes.size(), glyphIndexes.constData(), fixedPointPositions.data()); cache->fillInPendingGlyphs(); int margin = fontD->fontEngine->glyphMargin(cache->glyphFormat()); qreal glyphCacheScaleX = cache->transform().m11(); qreal glyphCacheScaleY = cache->transform().m22(); qreal glyphCacheInverseScaleX = 1.0 / glyphCacheScaleX; qreal glyphCacheInverseScaleY = 1.0 / glyphCacheScaleY; Q_ASSERT(geometry->indexType() == GL_UNSIGNED_SHORT); geometry->allocate(glyphIndexes.size() * 4, glyphIndexes.size() * 6); QVector4D *vp = (QVector4D *)geometry->vertexDataAsTexturedPoint2D(); Q_ASSERT(geometry->sizeOfVertex() == sizeof(QVector4D)); ushort *ip = geometry->indexDataAsUShort(); QPointF position(p.x(), p.y() - m_font.ascent()); bool supportsSubPixelPositions = fontD->fontEngine->supportsSubPixelPositions(); for (int i=0; i<glyphIndexes.size(); ++i) { QFixed subPixelPosition; if (supportsSubPixelPositions) subPixelPosition = fontD->fontEngine->subPixelPositionForX(QFixed::fromReal(glyphPositions.at(i).x())); QTextureGlyphCache::GlyphAndSubPixelPosition glyph(glyphIndexes.at(i), subPixelPosition); const QTextureGlyphCache::Coord &c = cache->coords.value(glyph); QPointF glyphPosition = glyphPositions.at(i) + position; // On a retina screen the glyph positions are not pre-scaled (as opposed to // eg. the raster paint engine). To ensure that we get the same behavior as // the raster engine (and CoreText itself) when it comes to rounding of the // coordinates, we need to apply the scale factor before rounding, and then // apply the inverse scale to get back to the coordinate system of the node. qreal x = (qFloor(glyphPosition.x() * glyphCacheScaleX) * glyphCacheInverseScaleX) + (c.baseLineX * glyphCacheInverseScaleX) - margin; qreal y = (qRound(glyphPosition.y() * glyphCacheScaleY) * glyphCacheInverseScaleY) - (c.baseLineY * glyphCacheInverseScaleY) - margin; qreal w = c.w * glyphCacheInverseScaleX; qreal h = c.h * glyphCacheInverseScaleY; *boundingRect |= QRectF(x + margin, y + margin, w, h); float cx1 = x - margins.left(); float cx2 = x + w + margins.right(); float cy1 = y - margins.top(); float cy2 = y + h + margins.bottom(); float tx1 = c.x - margins.left(); float tx2 = c.x + c.w + margins.right(); float ty1 = c.y - margins.top(); float ty2 = c.y + c.h + margins.bottom(); if (baseLine->isNull()) *baseLine = glyphPosition; vp[4 * i + 0] = QVector4D(cx1, cy1, tx1, ty1); vp[4 * i + 1] = QVector4D(cx2, cy1, tx2, ty1); vp[4 * i + 2] = QVector4D(cx1, cy2, tx1, ty2); vp[4 * i + 3] = QVector4D(cx2, cy2, tx2, ty2); int o = i * 4; ip[6 * i + 0] = o + 0; ip[6 * i + 1] = o + 2; ip[6 * i + 2] = o + 3; ip[6 * i + 3] = o + 3; ip[6 * i + 4] = o + 1; ip[6 * i + 5] = o + 0; } }
// Return the memory profile: used, available, total int US_Memory::memory_profile( int* pMemA, int* pMemT, int* pMemU ) { int memavail; int memtotal; int memused; int memavpc; #ifdef Q_OS_LINUX // Unix: use free command QProcess qproc; qproc.start( "free", QStringList() << "-m" ); qproc.waitForFinished( -1 ); QString totmem = QString( qproc.readAllStandardOutput() ).trimmed(); totmem = totmem.section( "\n", 1, 1 ); totmem.replace( QRegExp( "\\s+" ), " " ); qDebug() << " UsMEM:LINUX: totmem" << totmem; int fmtotal = totmem.section( " ", 1, 1 ).toInt(); int fmused = totmem.section( " ", 2, 2 ).toInt(); int fmfree = totmem.section( " ", 3, 3 ).toInt(); int fmbuffer = totmem.section( " ", 5, 5 ).toInt(); int fmcache = totmem.section( " ", 6, 6 ).toInt(); qDebug() << " UsMEM:LINUX: fmtotal,used,free,buffer,cache" << fmtotal << fmused << fmfree << fmbuffer << fmcache; memtotal = fmtotal; memused = qMax( fmused, ( fmtotal - fmfree - fmcache ) ); memavail = memtotal - memused; #endif #ifdef Q_OS_MAC // Mac: use sysctl and rss_now() const double mb_bytes = ( 1024. * 1024. ); const double kb_bytes = 1024.; QProcess qproc; qproc.start( "sysctl", QStringList() << "-n" << "hw.memsize" ); qproc.waitForFinished( -1 ); QString totmem = QString( qproc.readAllStandardOutput() ).trimmed(); memtotal = qRound( totmem.toDouble() / mb_bytes ); memused = qRound( (double)rss_now() / kb_bytes ); memavail = memtotal - memused; qDebug() << " UsMEM:Mac: totmem" << totmem << "memtotal" << memtotal; #endif #ifdef Q_OS_WIN // Windows: direct use of GlobalMemoryStatusEx const double mb_bytes = ( 1024. * 1024. ); MEMORYSTATUSEX mstatx; mstatx.dwLength = sizeof( mstatx ); GlobalMemoryStatusEx( &mstatx ); long memload = (long)mstatx.dwMemoryLoad; memtotal = qRound( (double)mstatx.ullTotalPhys / mb_bytes ); memavail = qRound( (double)mstatx.ullAvailPhys / mb_bytes ); memused = memtotal - memavail; memavpc = qRound( memavail * 100.0 / memtotal ); //qDebug() << " UsMEM:Win: mstatx.dwMemoryLoad" << mstatx.dwMemoryLoad; //qDebug() << " UsMEM:Win: mstatx.ullTotalPhys" << mstatx.ullTotalPhys; //qDebug() << " UsMEM:Win: mstatx.ullAvailPhys" << mstatx.ullAvailPhys; //qDebug() << " UsMEM:Win: gb_bytes" << gb_bytes; qDebug() << " UsMEM:Win: memload" << memload << "memavpc" << memavpc; #endif qDebug() << " UsMEM: memtotal,avail,used" << memtotal << memavail << memused; memavpc = qRound( memavail * 100.0 / memtotal ); if ( pMemA != NULL ) *pMemA = memavail; if ( pMemT != NULL ) *pMemT = memtotal; if ( pMemU != NULL ) *pMemU = memused; return memavpc; }
// The same, but with coordinates clipped to the nearest pixel QPoint qt_termCoord(unsigned int x, unsigned int y) { return QPoint(qRound(double(x)/qt_oversamplingF), qRound(double(term->ymax - y)/qt_oversamplingF)); }
void NSlider::setValue(qreal value) { QSlider::setValue(qRound(value * maximum())); }
/*! Render a plot to a file Supported formats are: - pdf\n Portable Document Format PDF - ps\n Postcript - svg\n Scalable Vector Graphics SVG - all image formats supported by Qt\n see QImageWriter::supportedImageFormats() Scalable vector graphic formats like PDF or SVG are superior to raster graphics formats. \param plot Plot widget \param fileName Path of the file, where the document will be stored \param format Format for the document \param sizeMM Size for the document in millimeters. \param resolution Resolution in dots per Inch (dpi) \sa renderTo(), render(), QwtPainter::setRoundingAlignment() */ void QwtPlotRenderer::renderDocument( QwtPlot *plot, const QString &fileName, const QString &format, const QSizeF &sizeMM, int resolution ) { if ( plot == NULL || sizeMM.isEmpty() || resolution <= 0 ) return; QString title = plot->title().text(); if ( title.isEmpty() ) title = "Plot Document"; const double mmToInch = 1.0 / 25.4; const QSizeF size = sizeMM * mmToInch * resolution; const QRectF documentRect( 0.0, 0.0, size.width(), size.height() ); const QString fmt = format.toLower(); if ( fmt == "pdf" || fmt == "ps" ) { #ifndef QT_NO_PRINTER QPrinter printer; printer.setFullPage( true ); printer.setPaperSize( sizeMM, QPrinter::Millimeter ); printer.setDocName( title ); printer.setOutputFileName( fileName ); printer.setOutputFormat( ( format == "pdf" ) ? QPrinter::PdfFormat : QPrinter::PostScriptFormat ); printer.setResolution( resolution ); QPainter painter( &printer ); render( plot, &painter, documentRect ); #endif } else if ( fmt == "svg" ) { #ifndef QWT_NO_SVG #ifdef QT_SVG_LIB #if QT_VERSION >= 0x040500 QSvgGenerator generator; generator.setTitle( title ); generator.setFileName( fileName ); generator.setResolution( resolution ); generator.setViewBox( documentRect ); QPainter painter( &generator ); render( plot, &painter, documentRect ); #endif #endif #endif } else { if ( QImageWriter::supportedImageFormats().indexOf( format.toLatin1() ) >= 0 ) { const QRect imageRect = documentRect.toRect(); const int dotsPerMeter = qRound( resolution * mmToInch * 1000.0 ); QImage image( imageRect.size(), QImage::Format_ARGB32 ); image.setDotsPerMeterX( dotsPerMeter ); image.setDotsPerMeterY( dotsPerMeter ); image.fill( QColor( Qt::white ).rgb() ); QPainter painter( &image ); render( plot, &painter, imageRect ); painter.end(); image.save( fileName, format.toLatin1() ); } } }
QRgb ColorElement::get_colorCached(const double &v) const { int key=qRound(v*curCacheCoef); return colorCache[key]; }
void ColorInspector::setColor(QColor newColor) { // this is a UI update function, never emit any signals // grab the color from color manager, and then update itself, that's it. // compare under the same color spec newColor = (isRgbColors) ? newColor.toRgb() : newColor.toHsv(); if (newColor == mCurrentColor) { return; } if(isRgbColors) { QSignalBlocker b1(ui->red_slider); QSignalBlocker b2(ui->green_slider); QSignalBlocker b3(ui->blue_slider); QSignalBlocker b4(ui->alpha_slider); ui->red_slider->setRgb(newColor); ui->green_slider->setRgb(newColor); ui->blue_slider->setRgb(newColor); ui->alpha_slider->setRgb(newColor); QSignalBlocker b5(ui->RedspinBox); QSignalBlocker b6(ui->GreenspinBox); QSignalBlocker b7(ui->BluespinBox); QSignalBlocker b8(ui->AlphaspinBox); ui->RedspinBox->setValue(newColor.red()); ui->GreenspinBox->setValue(newColor.green()); ui->BluespinBox->setValue(newColor.blue()); ui->AlphaspinBox->setValue(newColor.alpha()); } else { QSignalBlocker b1(ui->red_slider); QSignalBlocker b2(ui->green_slider); QSignalBlocker b3(ui->blue_slider); QSignalBlocker b4(ui->alpha_slider); ui->red_slider->setHsv(newColor); ui->green_slider->setHsv(newColor); ui->blue_slider->setHsv(newColor); ui->alpha_slider->setHsv(newColor); QSignalBlocker b5(ui->RedspinBox); QSignalBlocker b6(ui->GreenspinBox); QSignalBlocker b7(ui->BluespinBox); QSignalBlocker b8(ui->AlphaspinBox); ui->RedspinBox->setValue(newColor.hsvHue()); ui->GreenspinBox->setValue(qRound(newColor.hsvSaturation() / 2.55)); ui->BluespinBox->setValue(qRound(newColor.value() / 2.55)); ui->AlphaspinBox->setValue(qRound(newColor.alpha() / 2.55)); } mCurrentColor = newColor; QPalette p1 = ui->colorWrapper->palette(), p2 = ui->color->palette(); p1.setBrush(QPalette::Background, QBrush(QImage(":/background/checkerboard.png"))); p2.setColor(QPalette::Background, mCurrentColor); ui->colorWrapper->setPalette(p1); ui->color->setPalette(p2); update(); }
KoFilter::ConversionStatus ImageExport::convert(const QByteArray& from, const QByteArray& to) { if(from != "application/x-kivio") { return KoFilter::BadMimeType; } QString format; if(to == "image/png") { format = "PNG"; } else if(to == "image/jpeg") { format = "JPEG"; } else if(to == "image/bmp") { format = "BMP"; } else if(to == "image/x-eps") { format = "EPS"; } else if(to == "image/x-portable-bitmap") { format = "PBM"; } else if(to == "image/x-pcx") { format = "PCX"; } else if(to == "image/x-portable-pixmap") { format = "PPM"; } else if(to == "image/x-rgb") { format = "RGB"; } else if(to == "image/x-xpixmap") { format = "XPM"; } else if(to == "image/jpeg2000") { format = "JP2"; } else { return KoFilter::BadMimeType; } KoStoreDevice* storeIn = m_chain->storageFile("root", KoStore::Read); if (!storeIn) { KMessageBox::error(0, i18n("Failed to read data."), i18n( "Export Error" )); return KoFilter::FileNotFound; } // Get the XML tree. QDomDocument domIn; domIn.setContent(storeIn); KivioDoc doc; if(!doc.loadXML(0, domIn)) { KMessageBox::error(0, i18n("Malformed XML data."), i18n("Export Error")); return KoFilter::WrongFormat; } ImageExportDialog dlg; QStringList pageNames; Q3PtrList<KivioPage> pageList = doc.map()->pageList(); Q3PtrListIterator<KivioPage> it(pageList); for(; it.current() != 0; ++it) { pageNames.append(it.current()->pageName()); } KoZoomHandler zoom; dlg.setPageList(pageNames); KivioPage* page = doc.map()->firstPage(); QSize size = QSize(zoom.zoomItX(page->paperLayout().ptWidth), zoom.zoomItY(page->paperLayout().ptHeight)); dlg.setInitialCustomSize(size); if(dlg.exec() != QDialog::Accepted) { return KoFilter::UserCancelled; } page = doc.map()->findPage(dlg.selectedPage()); if(!page) { kDebug() <<"The page named" << dlg.selectedPage() <<" wasn't found!!"; return KoFilter::InternalError; } if(dlg.usePageBorders()) { size = QSize(zoom.zoomItX(page->paperLayout().ptWidth), zoom.zoomItY(page->paperLayout().ptHeight)); } else { size = zoom.zoomSize(page->getRectForAllStencils().size()); } if(dlg.useCustomSize()) { QSize customSize = dlg.customSize(); float zw = (float)customSize.width() / (float)size.width(); float zh = (float)customSize.height() / (float)size.height(); float z = qMin(zw, zh); zoom.setZoomAndResolution(qRound(z * 100), KoGlobal::dpiX(), KoGlobal::dpiY()); size = customSize; } int border = dlg.margin(); size.setWidth(size.width() + (border * 2)); size.setHeight(size.height() + (border * 2)); QPixmap pixmap = QPixmap(size); pixmap.fill(Qt::white); KivioScreenPainter kpainter; kpainter.start(&pixmap); int translationX = border; int translationY = border; if(!dlg.usePageBorders()) { QPoint point = zoom.zoomPoint(page->getRectForAllStencils().topLeft()); translationX += point.x(); translationY += point.y(); } kpainter.setTranslation(-translationX, -translationY); page->printContent(kpainter, &zoom); if(!pixmap.save(m_chain->outputFile(), format.local8Bit())) { return KoFilter::CreationError; } return KoFilter::OK; }
void PlayerWidget::paintEvent(QPaintEvent *e) { Painter p(this); QRect r(e->rect()), checkr(myrtlrect(r)); p.fillRect(r, st::playerBg->b); if (!_playbackRect.contains(checkr)) { if (_fullAvailable && checkr.intersects(_prevRect)) { if (_prevAvailable) { float64 o = _stateHovers[OverPrev]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); } else { p.setOpacity(st::playerUnavailableOpacity); } p.drawSpriteCenterLeft(_prevRect, width(), st::playerPrev); } if (checkr.intersects(_playRect)) { float64 o = _stateHovers[OverPlay]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); p.drawSpriteCenterLeft(_playRect, width(), (_showPause || _down == OverPlayback) ? st::playerPause : st::playerPlay); } if (_fullAvailable && checkr.intersects(_nextRect)) { if (_nextAvailable) { float64 o = _stateHovers[OverNext]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); } else { p.setOpacity(st::playerUnavailableOpacity); } p.drawSpriteCenterLeft(_nextRect, width(), st::playerNext); } if (checkr.intersects(_closeRect)) { float64 o = _stateHovers[OverClose]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); p.drawSpriteCenterLeft(_closeRect, width(), st::playerClose); } if (checkr.intersects(_volumeRect)) { float64 o = _stateHovers[OverVolume]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); int32 top = _volumeRect.y() + (_volumeRect.height() - st::playerVolume.pxHeight()) / 2; int32 left = _volumeRect.x() + (_volumeRect.width() - st::playerVolume.pxWidth()) / 2; int32 mid = left + qRound(st::playerVolume.pxWidth() * cSongVolume()); int32 right = left + st::playerVolume.pxWidth(); if (rtl()) { left = width() - left; mid = width() - mid; right = width() - right; if (mid < left) { p.drawPixmap(QRect(mid, top, left - mid, st::playerVolume.pxHeight()), App::sprite(), QRect(st::playerVolume.rect().x() + (mid - right) * cIntRetinaFactor(), st::playerVolume.rect().y(), (left - mid) * cIntRetinaFactor(), st::playerVolume.pxHeight() * cIntRetinaFactor())); } if (right < mid) { p.setOpacity(st::playerUnavailableOpacity); p.drawPixmap(QRect(right, top, mid - right, st::playerVolume.pxHeight()), App::sprite(), QRect(st::playerVolume.rect().x(), st::playerVolume.rect().y(), (mid - right) * cIntRetinaFactor(), st::playerVolume.pxHeight() * cIntRetinaFactor())); } } else { if (mid > left) { p.drawPixmap(QRect(left, top, mid - left, st::playerVolume.pxHeight()), App::sprite(), QRect(st::playerVolume.rect().x(), st::playerVolume.rect().y(), (mid - left) * cIntRetinaFactor(), st::playerVolume.pxHeight() * cIntRetinaFactor())); } if (right > mid) { p.setOpacity(st::playerUnavailableOpacity); p.drawPixmap(QRect(mid, top, right - mid, st::playerVolume.pxHeight()), App::sprite(), QRect(st::playerVolume.rect().x() + (mid - left) * cIntRetinaFactor(), st::playerVolume.rect().y(), (right - mid) * cIntRetinaFactor(), st::playerVolume.pxHeight() * cIntRetinaFactor())); } } } if (_fullAvailable && checkr.intersects(_fullRect)) { float64 o = _stateHovers[OverFull]; p.setOpacity(o * 1. + (1. - o) * st::playerInactiveOpacity); p.drawSpriteCenterLeft(_fullRect, width(), st::playerFull); } if (checkr.intersects(_repeatRect)) { float64 o = _stateHovers[OverRepeat]; p.setOpacity(_repeat ? 1. : (o * st::playerInactiveOpacity + (1. - o) * st::playerUnavailableOpacity)); p.drawSpriteCenterLeft(_repeatRect, width(), st::playerRepeat); } p.setOpacity(1.); p.setPen(st::playerTimeFg->p); p.setFont(st::linkFont->f); p.drawTextLeft(_infoRect.x() + _infoRect.width() - _timeWidth, _infoRect.y() + (_infoRect.height() - st::linkFont->height) / 2, width(), _time, _timeWidth); textstyleSet(&st::playerNameStyle); p.setPen(st::playerFg->p); _name.drawElided(p, _infoRect.x() + (rtl() ? (_timeWidth + st::playerSkip) : 0), _infoRect.y() + (_infoRect.height() - st::linkFont->height) / 2, _infoRect.width() - _timeWidth - st::playerSkip); textstyleRestore(); } if (_duration) { float64 prg = (_down == OverPlayback) ? _downProgress : a_progress.current(); int32 from = _playbackRect.x(), mid = qRound(_playbackRect.x() + prg * _playbackRect.width()), end = _playbackRect.x() + _playbackRect.width(); if (mid > from) { p.fillRect(rtl() ? (width() - mid) : from, height() - st::playerLineHeight, mid - from, _playbackRect.height(), st::playerLineActive->b); } if (end > mid) { p.fillRect(rtl() ? (width() - end) : mid, height() - st::playerLineHeight, end - mid, st::playerLineHeight, st::playerLineInactive->b); } if (_stateHovers[OverPlayback] > 0) { p.setOpacity(_stateHovers[OverPlayback]); int32 x = mid - (st::playerMoverSize.width() / 2); p.fillRect(rtl() ? (width() - x - st::playerMoverSize.width()) : x, height() - st::playerMoverSize.height(), st::playerMoverSize.width(), st::playerMoverSize.height(), st::playerLineActive->b); } } else if (a_loadProgress.current() > 0) { int32 from = _playbackRect.x(), mid = qRound(_playbackRect.x() + a_loadProgress.current() * _playbackRect.width()); if (mid > from) { p.fillRect(rtl() ? (width() - mid) : from, height() - st::playerLineHeight, mid - from, _playbackRect.height(), st::playerLineInactive->b); } } }
void XfigPlug::useColor(int colorNum, int area_fill, bool forFill) { QString color = CommonStrings::None; int shade = 100; if (forFill) { if (area_fill == -1) color = CommonStrings::None; else { if ((colorNum == -1) || (colorNum == 0)) { if (area_fill == 0) { color = "White"; shade = 100; } else if (area_fill == 20) { color = "Black"; shade = 100; } else if ((area_fill > 0) && (area_fill < 20)) { color = "Black"; shade = qRound(100.0 / 19.0 * area_fill); } } else if (colorNum == 7) { if (area_fill == 0) { color = "Black"; shade = 100; } else if (area_fill == 20) { color = "White"; shade = 100; } else if ((area_fill > 0) && (area_fill < 20)) { color = "Black"; shade = qRound(100.0 / 19.0 * (20 - area_fill)); } } else { if (importedColors.contains(colorNum)) { color = importedColors[colorNum]; if (!m_Doc->PageColors.contains(color)) m_Doc->PageColors.insert(color, CustColors[color]); int sat = area_fill - 20; if ((sat > 0) && (sat < 20)) shade = qRound(100.0 / 19.0 * sat); } else color = CommonStrings::None; } } CurrColorFill = color; CurrFillShade = shade; } else { if (area_fill == -1) CurrColorStroke = CommonStrings::None; else { if ((colorNum == -1) || (colorNum == 0)) CurrColorStroke = "Black"; else { if (importedColors.contains(colorNum)) { CurrColorStroke = importedColors[colorNum]; if (!m_Doc->PageColors.contains(CurrColorStroke)) m_Doc->PageColors.insert(CurrColorStroke, CustColors[CurrColorStroke]); } else CurrColorStroke = CommonStrings::None; } } } }
bool EPSPlug::convert(QString fn, double x, double y, double b, double h) { QStringList args; QString cmd, cmd1, cmd2, cmd3, tmp, tmp2, tmp3, tmp4; // import.prolog do not cope with filenames containing blank spaces // so take care that output filename does not (win32 compatibility) QString tmpFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.out"; QString errFile = getShortPathName(ScPaths::getTempFileDir())+ "/ps.err"; QString pfad = ScPaths::instance().libDir(); QString pfad2 = QDir::toNativeSeparators(pfad + "import.prolog"); QFileInfo fi = QFileInfo(fn); QString ext = fi.suffix().toLower(); if (progressDialog) { progressDialog->setOverallProgress(1); qApp->processEvents(); } /* // Destill the eps with ghostscript to get a clean eps file QString cleanFile = getShortPathName(ScPaths::getTempFileDir())+ "/clean.eps"; args.append( "-q" ); args.append( "-dNOPAUSE" ); args.append( "-sDEVICE=epswrite" ); args.append( "-dBATCH" ); args.append( "-dSAFER" ); args.append( "-dDEVICEWIDTH=250000" ); args.append( "-dDEVICEHEIGHT=250000" ); args.append( QString("-sOutputFile=%1").arg(QDir::toNativeSeparators(cleanFile)) ); args.append( QDir::toNativeSeparators(fn) ); System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel); args.clear(); */ args.append( "-q" ); args.append( "-dNOPAUSE" ); args.append( "-dNODISPLAY" ); args.append( "-dBATCH" ); args.append( "-dDELAYBIND" ); // Add any extra font paths being used by Scribus to gs's font search // path We have to use Scribus's prefs context, not a plugin context, to // get to the required information. PrefsContext *pc = PrefsManager::instance()->prefsFile->getContext("Fonts"); PrefsTable *extraFonts = pc->getTable("ExtraFontDirs"); const char sep = ScPaths::envPathSeparator; if (extraFonts->getRowCount() >= 1) cmd = QString("-sFONTPATH=%1").arg(extraFonts->get(0,0)); for (int i = 1; i < extraFonts->getRowCount(); ++i) cmd += QString("%1%2").arg(sep).arg(extraFonts->get(i,0)); if( !cmd.isEmpty() ) args.append( cmd ); // then finish building the command and call gs args.append( QString("-g%1x%2").arg(tmp2.setNum(qRound((b-x)*4))).arg(tmp3.setNum(qRound((h-y)*4))) ); args.append( "-r288"); args.append( "-dTextAlphaBits=4" ); args.append( "-dGraphicsAlphaBits=4" ); args.append( "-c" ); args.append( tmp.setNum(-x) ); args.append( tmp.setNum(-y) ); args.append( "translate" ); args.append( QString("-sTraceFile=%1").arg(QDir::toNativeSeparators(tmpFile)) ); QString exportPath = m_Doc->DocName + "-" + fi.baseName(); QFileInfo exportFi(exportPath); if ( !exportFi.isWritable() ) { PrefsContext* docContext = PrefsManager::instance()->prefsFile->getContext("docdirs", false); QString docDir = "."; QString prefsDocDir=PrefsManager::instance()->documentDir(); if (!prefsDocDir.isEmpty()) docDir = docContext->get("docsopen", prefsDocDir); else docDir = docContext->get("docsopen", "."); exportFi.setFile(docDir + "/" + exportFi.baseName()); } //qDebug() << QString("using export path %1").arg(exportFi.absFilePath()); args.append( QString("-sExportFiles=%1").arg(QDir::toNativeSeparators(exportFi.absoluteFilePath())) ); args.append( pfad2 ); args.append( QDir::toNativeSeparators(fn) ); args.append( "-c" ); args.append( "flush" ); args.append( "cfile" ); args.append( "closefile" ); args.append( "quit" ); QByteArray finalCmd = args.join(" ").toLocal8Bit(); int ret = System(getShortPathName(PrefsManager::instance()->ghostscriptExecutable()), args, errFile, errFile, &cancel); if (ret != 0 && !cancel) { qDebug("PostScript import failed when calling gs as: \n%s\n", finalCmd.data()); qDebug("%s", "Ghostscript diagnostics:\n"); QFile diag(errFile); if (diag.open(QIODevice::ReadOnly) && !diag.atEnd() ) { char buf[121]; while (diag.readLine(buf, 120) > 0) { qDebug("\t%s", buf); } diag.close(); } else { qDebug("%s", "-- no output --"); } if (progressDialog) progressDialog->close(); QString mess = tr("Importing File:\n%1\nfailed!").arg(fn); ScMessageBox::critical(0, tr("Fatal Error"), mess); return false; } if(progressDialog && !cancel) { progressDialog->setOverallProgress(2); progressDialog->setLabel("GI", tr("Generating Items")); qApp->processEvents(); } if (!cancel) { parseOutput(tmpFile, extensionIndicatesEPSorPS(ext)); } QFile::remove(tmpFile); // QFile::remove(cleanFile); if (progressDialog) progressDialog->close(); return true; }
void DkColorSlider::updatePos(int parentWidth) { int pos = qRound(mNormedPos * (parentWidth - mSliderWidth - 1)); setGeometry(pos, 23, mSliderWidth + 1, mSliderWidth + mSliderHalfWidth + 1); }
bool PvrEglScreen::connect(const QString &displaySpec) { if (!pvrQwsDisplayOpen()) return false; // Initialize the QScreen properties. data = (uchar *)(pvrQwsDisplay.screens[0].mapped); w = pvrQwsDisplay.screens[0].screenRect.width; h = pvrQwsDisplay.screens[0].screenRect.height; lstep = pvrQwsDisplay.screens[0].screenStride; dw = w; dh = h; size = h * lstep; mapsize = size; switch (pvrQwsDisplay.screens[0].pixelFormat) { case PVR2D_RGB565: d = 16; setPixelFormat(QImage::Format_RGB16); break; case PVR2D_ARGB4444: d = 16; setPixelFormat(QImage::Format_ARGB4444_Premultiplied); break; case PVR2D_ARGB8888: d = 32; setPixelFormat(QImage::Format_ARGB32_Premultiplied); break; default: pvrQwsDisplayClose(); qWarning("PvrEglScreen::connect: unsupported pixel format %d", (int)(pvrQwsDisplay.screens[0].pixelFormat)); return false; } // Handle display physical size spec. QStringList displayArgs = displaySpec.split(QLatin1Char(':')); QRegExp mmWidthRx(QLatin1String("mmWidth=?(\\d+)")); int dimIdxW = displayArgs.indexOf(mmWidthRx); QRegExp mmHeightRx(QLatin1String("mmHeight=?(\\d+)")); int dimIdxH = displayArgs.indexOf(mmHeightRx); if (dimIdxW >= 0) { mmWidthRx.exactMatch(displayArgs.at(dimIdxW)); physWidth = mmWidthRx.cap(1).toInt(); if (dimIdxH < 0) physHeight = dh*physWidth/dw; } if (dimIdxH >= 0) { mmHeightRx.exactMatch(displayArgs.at(dimIdxH)); physHeight = mmHeightRx.cap(1).toInt(); if (dimIdxW < 0) physWidth = dw*physHeight/dh; } if (dimIdxW < 0 && dimIdxH < 0) { const int dpi = 72; physWidth = qRound(dw * 25.4 / dpi); physHeight = qRound(dh * 25.4 / dpi); } // Find the name of the tty device to use. QRegExp ttyRegExp(QLatin1String("tty=(.*)")); if (displayArgs.indexOf(ttyRegExp) != -1) ttyDevice = ttyRegExp.cap(1); if (displayArgs.contains(QLatin1String("nographicsmodeswitch"))) doGraphicsMode = false; #ifdef QT_WEBOS setGraphicsSystem(new PvrEglScreenPrivate); #endif // QT_WEBOS // The screen is ready. return true; }
void DkGradient::insertSlider(qreal pos, QColor col) { // Inserts a new slider at position pos and calculates the color, interpolated from the closest neighbors. // Find the neighbors of the new slider, since we need it for the color interpolation: QColor leftColor, rightColor, actColor; qreal dist; qreal initValue = DBL_MAX; //std::numeric_limits<qreal>::max(); // >DIR: fix for linux [9.2.2012 markus] qreal leftDist = initValue; qreal rightDist = initValue; int leftIdx = 0, rightIdx = 0; for (int i = 0; i < mSliders.size(); i++) { dist = mSliders.at(i)->getNormedPos() - pos; if (dist < 0) { if (std::abs(dist) < leftDist) { leftDist = (std::abs(dist)); leftIdx = i; } } else if (dist > 0){ if (std::abs(dist) < rightDist) { rightDist = (std::abs(dist)); rightIdx = i; } } else { actColor = mSliders.at(i)->getColor(); break; } } if ((leftDist == initValue) && (rightDist == initValue)) actColor = Qt::black; // The slider is most left: else if (leftDist == initValue) actColor = mSliders.at(rightIdx)->getColor(); // The slider is most right: else if (rightDist == initValue) actColor = mSliders.at(leftIdx)->getColor(); // The slider has a neighbor to the left and to the right: else { int rLeft, rRight, rNew, gLeft, gRight, gNew, bLeft, bRight, bNew; mSliders.at(leftIdx)->getColor().getRgb(&rLeft, &gLeft, &bLeft); mSliders.at(rightIdx)->getColor().getRgb(&rRight, &gRight, &bRight); qreal fac = leftDist / (leftDist + rightDist); rNew = qRound(rLeft * (1 - fac) + rRight * fac); gNew = qRound(gLeft * (1 - fac) + gRight * fac); bNew = qRound(bLeft * (1 - fac) + bRight * fac); actColor = QColor(rNew, gNew, bNew); } addSlider(pos, col.isValid() ? col : actColor); // The last slider in the list is the last one added, now make this one active: activateSlider(mSliders.last()); updateGradient(); update(); }
bool QLinuxFbScreen::connect(const QString &displaySpec) { d_ptr->displaySpec = displaySpec; const QStringList args = displaySpec.split(QLatin1Char(':')); if (args.contains(QLatin1String("nographicsmodeswitch"))) d_ptr->doGraphicsMode = false; #ifdef QT_QWS_DEPTH_GENERIC if (args.contains(QLatin1String("genericcolors"))) d_ptr->doGenericColors = true; #endif QRegExp ttyRegExp(QLatin1String("tty=(.*)")); if (args.indexOf(ttyRegExp) != -1) d_ptr->ttyDevice = ttyRegExp.cap(1); #if Q_BYTE_ORDER == Q_BIG_ENDIAN #ifndef QT_QWS_FRAMEBUFFER_LITTLE_ENDIAN if (args.contains(QLatin1String("littleendian"))) #endif QScreen::setFrameBufferLittleEndian(true); #endif QString dev = QLatin1String("/dev/fb0"); foreach(QString d, args) { if (d.startsWith(QLatin1Char('/'))) { dev = d; break; } } if (access(dev.toLatin1().constData(), R_OK|W_OK) == 0) d_ptr->fd = QT_OPEN(dev.toLatin1().constData(), O_RDWR); if (d_ptr->fd == -1) { if (QApplication::type() == QApplication::GuiServer) { perror("QScreenLinuxFb::connect"); qCritical("Error opening framebuffer device %s", qPrintable(dev)); return false; } if (access(dev.toLatin1().constData(), R_OK) == 0) d_ptr->fd = QT_OPEN(dev.toLatin1().constData(), O_RDONLY); } ::fb_fix_screeninfo finfo; ::fb_var_screeninfo vinfo; //####################### // Shut up Valgrind memset(&vinfo, 0, sizeof(vinfo)); memset(&finfo, 0, sizeof(finfo)); //####################### /* Get fixed screen information */ if (d_ptr->fd != -1 && ioctl(d_ptr->fd, FBIOGET_FSCREENINFO, &finfo)) { perror("QLinuxFbScreen::connect"); qWarning("Error reading fixed information"); return false; } if (finfo.type == FB_TYPE_VGA_PLANES) { qWarning("VGA16 video mode not supported"); return false; } /* Get variable screen information */ if (d_ptr->fd != -1 && ioctl(d_ptr->fd, FBIOGET_VSCREENINFO, &vinfo)) { perror("QLinuxFbScreen::connect"); qWarning("Error reading variable information"); return false; } grayscale = vinfo.grayscale; d = vinfo.bits_per_pixel; if (d == 24) { d = vinfo.red.length + vinfo.green.length + vinfo.blue.length; if (d <= 0) d = 24; // reset if color component lengths are not reported } else if (d == 16) { d = vinfo.red.length + vinfo.green.length + vinfo.blue.length; if (d <= 0) d = 16; } lstep = finfo.line_length; int xoff = vinfo.xoffset; int yoff = vinfo.yoffset; const char* qwssize; if((qwssize=::getenv("QWS_SIZE")) && sscanf(qwssize,"%dx%d",&w,&h)==2) { if (d_ptr->fd != -1) { if ((uint)w > vinfo.xres) w = vinfo.xres; if ((uint)h > vinfo.yres) h = vinfo.yres; } dw=w; dh=h; int xxoff, yyoff; if (sscanf(qwssize, "%*dx%*d+%d+%d", &xxoff, &yyoff) == 2) { if (xxoff < 0 || xxoff + w > vinfo.xres) xxoff = vinfo.xres - w; if (yyoff < 0 || yyoff + h > vinfo.yres) yyoff = vinfo.yres - h; xoff += xxoff; yoff += yyoff; } else { xoff += (vinfo.xres - w)/2; yoff += (vinfo.yres - h)/2; } } else { dw=w=vinfo.xres; dh=h=vinfo.yres; } if (w == 0 || h == 0) { qWarning("QScreenLinuxFb::connect(): Unable to find screen geometry, " "will use 320x240."); dw = w = 320; dh = h = 240; } setPixelFormat(vinfo); // Handle display physical size spec. QStringList displayArgs = displaySpec.split(QLatin1Char(':')); QRegExp mmWidthRx(QLatin1String("mmWidth=?(\\d+)")); int dimIdxW = displayArgs.indexOf(mmWidthRx); QRegExp mmHeightRx(QLatin1String("mmHeight=?(\\d+)")); int dimIdxH = displayArgs.indexOf(mmHeightRx); if (dimIdxW >= 0) { mmWidthRx.exactMatch(displayArgs.at(dimIdxW)); physWidth = mmWidthRx.cap(1).toInt(); if (dimIdxH < 0) physHeight = dh*physWidth/dw; } if (dimIdxH >= 0) { mmHeightRx.exactMatch(displayArgs.at(dimIdxH)); physHeight = mmHeightRx.cap(1).toInt(); if (dimIdxW < 0) physWidth = dw*physHeight/dh; } if (dimIdxW < 0 && dimIdxH < 0) { if (vinfo.width != 0 && vinfo.height != 0 && vinfo.width != UINT_MAX && vinfo.height != UINT_MAX) { physWidth = vinfo.width; physHeight = vinfo.height; } else { const int dpi = 72; physWidth = qRound(dw * 25.4 / dpi); physHeight = qRound(dh * 25.4 / dpi); } } dataoffset = yoff * lstep + xoff * d / 8; //qDebug("Using %dx%dx%d screen",w,h,d); /* Figure out the size of the screen in bytes */ size = h * lstep; mapsize = finfo.smem_len; data = (unsigned char *)-1; if (d_ptr->fd != -1) data = (unsigned char *)mmap(0, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, d_ptr->fd, 0); if ((long)data == -1) { if (QApplication::type() == QApplication::GuiServer) { perror("QLinuxFbScreen::connect"); qWarning("Error: failed to map framebuffer device to memory."); return false; } data = 0; } else { data += dataoffset; } canaccel = useOffscreen(); if(canaccel) setupOffScreen(); // Now read in palette if((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4)) { screencols= (vinfo.bits_per_pixel==8) ? 256 : 16; int loopc; ::fb_cmap startcmap; startcmap.start=0; startcmap.len=screencols; startcmap.red=(unsigned short int *) malloc(sizeof(unsigned short int)*screencols); startcmap.green=(unsigned short int *) malloc(sizeof(unsigned short int)*screencols); startcmap.blue=(unsigned short int *) malloc(sizeof(unsigned short int)*screencols); startcmap.transp=(unsigned short int *) malloc(sizeof(unsigned short int)*screencols); if (d_ptr->fd == -1 || ioctl(d_ptr->fd, FBIOGETCMAP, &startcmap)) { perror("QLinuxFbScreen::connect"); qWarning("Error reading palette from framebuffer, using default palette"); createPalette(startcmap, vinfo, finfo); } int bits_used = 0; for(loopc=0;loopc<screencols;loopc++) { screenclut[loopc]=qRgb(startcmap.red[loopc] >> 8, startcmap.green[loopc] >> 8, startcmap.blue[loopc] >> 8); bits_used |= startcmap.red[loopc] | startcmap.green[loopc] | startcmap.blue[loopc]; } // WORKAROUND: Some framebuffer drivers only return 8 bit // color values, so we need to not bit shift them.. if ((bits_used & 0x00ff) && !(bits_used & 0xff00)) { for(loopc=0;loopc<screencols;loopc++) { screenclut[loopc] = qRgb(startcmap.red[loopc], startcmap.green[loopc], startcmap.blue[loopc]); } qWarning("8 bits cmap returned due to faulty FB driver, colors corrected"); } free(startcmap.red); free(startcmap.green); free(startcmap.blue); free(startcmap.transp); } else {
void BrushTool::drawStroke() { StrokeTool::drawStroke(); QList<QPointF> p = m_pStrokeManager->interpolateStroke(); Layer* layer = mEditor->layers()->currentLayer(); if ( layer->type() == Layer::BITMAP ) { for ( int i = 0; i < p.size(); i++ ) { p[ i ] = mEditor->view()->mapScreenToCanvas( p[ i ] ); } qreal opacity = 1.0; qreal brushWidth = mCurrentWidth + 0.5 * properties.feather; qreal offset = qMax( 0.0, mCurrentWidth - 0.5 * properties.feather ) / brushWidth; opacity = mCurrentPressure; brushWidth = brushWidth * mCurrentPressure; qreal brushStep = 0.5 * mCurrentWidth + 0.5 * properties.feather; brushStep = brushStep * mCurrentPressure; // if (usePressure) { brushStep = brushStep * tabletPressure; } brushStep = qMax( 1.0, brushStep ); mCurrentWidth = properties.width; BlitRect rect; QRadialGradient radialGrad( QPointF( 0, 0 ), 0.5 * brushWidth ); mScribbleArea->setGaussianGradient( radialGrad, mEditor->color()->frontColor(), opacity, offset ); QPointF a = lastBrushPoint; QPointF b = getCurrentPoint(); // foreach (QSegment segment, calculateStroke(brushWidth)) // { // QPointF a = lastBrushPoint; // QPointF b = m_pScribbleArea->pixelToPoint(segment.second); qreal distance = 4 * QLineF( b, a ).length(); int steps = qRound( distance ) / brushStep; for ( int i = 0; i < steps; i++ ) { QPointF point = lastBrushPoint + ( i + 1 ) * ( brushStep )* ( b - lastBrushPoint ) / distance; rect.extend( point.toPoint() ); mScribbleArea->drawBrush( point, brushWidth, offset, mEditor->color()->frontColor(), opacity ); if ( i == ( steps - 1 ) ) { lastBrushPoint = point; } } int rad = qRound( brushWidth ) / 2 + 2; mScribbleArea->refreshBitmap( rect, rad ); } else if ( layer->type() == Layer::VECTOR ) { QPen pen( Qt::gray, 1, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin ); int rad = qRound( ( mCurrentWidth / 2 + 2 ) * qAbs( mEditor->view()->scaling() ) ); // foreach (QSegment segment, calculateStroke(currentWidth)) // { // QPointF a = segment.first; // QPointF b = segment.second; // m_pScribbleArea->drawLine(a, b, pen, QPainter::CompositionMode_SourceOver); // m_pScribbleArea->refreshVector(QRect(a.toPoint(), b.toPoint()), rad); // } if ( p.size() == 4 ) { QSizeF size( 2, 2 ); QPainterPath path( p[ 0 ] ); path.cubicTo( p[ 1 ], p[ 2 ], p[ 3 ] ); mScribbleArea->drawPath( path, pen, Qt::NoBrush, QPainter::CompositionMode_Source ); mScribbleArea->refreshVector( path.boundingRect().toRect(), rad ); } } }