static void _setStandardTestFont( QgsLegendSettings& settings, const QString& style = QStringLiteral( "Roman" ) )
{
QList< QgsLegendStyle::Style> styles;
styles << QgsLegendStyle::Title
<< QgsLegendStyle::Group
<< QgsLegendStyle::Subgroup
<< QgsLegendStyle::SymbolLabel;
Q_FOREACH ( QgsLegendStyle::Style st, styles )
{
QFont font( QgsFontUtils::getStandardTestFont( style ) );
font.setPointSizeF( settings.style( st ).font().pointSizeF() );
settings.rstyle( st ).setFont( font );
}
///@endcond
///
QgsRasterLayerRenderer::QgsRasterLayerRenderer( QgsRasterLayer *layer, QgsRenderContext &rendererContext )
: QgsMapLayerRenderer( layer->id() )
, mContext( rendererContext )
, mFeedback( new QgsRasterLayerRendererFeedback( this ) )
{
mPainter = rendererContext.painter();
const QgsMapToPixel &qgsMapToPixel = rendererContext.mapToPixel();
mMapToPixel = &qgsMapToPixel;
QgsMapToPixel mapToPixel = qgsMapToPixel;
if ( mapToPixel.mapRotation() )
{
// unset rotation for the sake of local computations.
// Rotation will be handled by QPainter later
// TODO: provide a method of QgsMapToPixel to fetch map center
// in geographical units
QgsPointXY center = mapToPixel.toMapCoordinates(
static_cast<int>( mapToPixel.mapWidth() / 2.0 ),
static_cast<int>( mapToPixel.mapHeight() / 2.0 )
);
mapToPixel.setMapRotation( 0, center.x(), center.y() );
}
QgsRectangle myProjectedViewExtent;
QgsRectangle myProjectedLayerExtent;
if ( rendererContext.coordinateTransform().isValid() )
{
QgsDebugMsgLevel( QStringLiteral( "coordinateTransform set -> project extents." ), 4 );
if ( rendererContext.extent().xMinimum() == std::numeric_limits<double>::lowest() &&
rendererContext.extent().yMinimum() == std::numeric_limits<double>::lowest() &&
rendererContext.extent().xMaximum() == std::numeric_limits<double>::max() &&
rendererContext.extent().yMaximum() == std::numeric_limits<double>::max() )
{
// We get in this situation if the view CRS is geographical and the
// extent goes beyond -180,-90,180,90. To avoid reprojection issues to the
// layer CRS, then this dummy extent is returned by QgsMapRendererJob::reprojectToLayerExtent()
// Don't try to reproject it now to view extent as this would return
// a null rectangle.
myProjectedViewExtent = rendererContext.extent();
}
else
{
try
{
myProjectedViewExtent = rendererContext.coordinateTransform().transformBoundingBox( rendererContext.extent() );
}
catch ( QgsCsException &cs )
{
QgsMessageLog::logMessage( QObject::tr( "Could not reproject view extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
myProjectedViewExtent.setMinimal();
}
}
try
{
myProjectedLayerExtent = rendererContext.coordinateTransform().transformBoundingBox( layer->extent() );
}
catch ( QgsCsException &cs )
{
QgsMessageLog::logMessage( QObject::tr( "Could not reproject layer extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
myProjectedLayerExtent.setMinimal();
}
}
else
{
QgsDebugMsgLevel( QStringLiteral( "coordinateTransform not set" ), 4 );
myProjectedViewExtent = rendererContext.extent();
myProjectedLayerExtent = layer->extent();
}
// clip raster extent to view extent
QgsRectangle myRasterExtent = myProjectedViewExtent.intersect( myProjectedLayerExtent );
if ( myRasterExtent.isEmpty() )
{
QgsDebugMsg( QStringLiteral( "draw request outside view extent." ) );
// nothing to do
return;
}
QgsDebugMsgLevel( "theViewExtent is " + rendererContext.extent().toString(), 4 );
QgsDebugMsgLevel( "myProjectedViewExtent is " + myProjectedViewExtent.toString(), 4 );
QgsDebugMsgLevel( "myProjectedLayerExtent is " + myProjectedLayerExtent.toString(), 4 );
QgsDebugMsgLevel( "myRasterExtent is " + myRasterExtent.toString(), 4 );
//
// The first thing we do is set up the QgsRasterViewPort. This struct stores all the settings
// relating to the size (in pixels and coordinate system units) of the raster part that is
// in view in the map window. It also stores the origin.
//
//this is not a class level member because every time the user pans or zooms
//the contents of the rasterViewPort will change
mRasterViewPort = new QgsRasterViewPort();
mRasterViewPort->mDrawnExtent = myRasterExtent;
if ( rendererContext.coordinateTransform().isValid() )
{
mRasterViewPort->mSrcCRS = layer->crs();
mRasterViewPort->mDestCRS = rendererContext.coordinateTransform().destinationCrs();
mRasterViewPort->mSrcDatumTransform = rendererContext.coordinateTransform().sourceDatumTransformId();
mRasterViewPort->mDestDatumTransform = rendererContext.coordinateTransform().destinationDatumTransformId();
}
else
{
mRasterViewPort->mSrcCRS = QgsCoordinateReferenceSystem(); // will be invalid
mRasterViewPort->mDestCRS = QgsCoordinateReferenceSystem(); // will be invalid
mRasterViewPort->mSrcDatumTransform = -1;
mRasterViewPort->mDestDatumTransform = -1;
}
// get dimensions of clipped raster image in device coordinate space (this is the size of the viewport)
mRasterViewPort->mTopLeftPoint = mapToPixel.transform( myRasterExtent.xMinimum(), myRasterExtent.yMaximum() );
mRasterViewPort->mBottomRightPoint = mapToPixel.transform( myRasterExtent.xMaximum(), myRasterExtent.yMinimum() );
// align to output device grid, i.e. std::floor/ceil to integers
// TODO: this should only be done if paint device is raster - screen, image
// for other devices (pdf) it can have floating point origin
// we could use floating point for raster devices as well, but respecting the
// output device grid should make it more effective as the resampling is done in
// the provider anyway
mRasterViewPort->mTopLeftPoint.setX( std::floor( mRasterViewPort->mTopLeftPoint.x() ) );
mRasterViewPort->mTopLeftPoint.setY( std::floor( mRasterViewPort->mTopLeftPoint.y() ) );
mRasterViewPort->mBottomRightPoint.setX( std::ceil( mRasterViewPort->mBottomRightPoint.x() ) );
mRasterViewPort->mBottomRightPoint.setY( std::ceil( mRasterViewPort->mBottomRightPoint.y() ) );
// recalc myRasterExtent to aligned values
myRasterExtent.set(
mapToPixel.toMapCoordinates( mRasterViewPort->mTopLeftPoint.x(),
mRasterViewPort->mBottomRightPoint.y() ),
mapToPixel.toMapCoordinates( mRasterViewPort->mBottomRightPoint.x(),
mRasterViewPort->mTopLeftPoint.y() )
);
//raster viewport top left / bottom right are already rounded to int
mRasterViewPort->mWidth = static_cast<int>( mRasterViewPort->mBottomRightPoint.x() - mRasterViewPort->mTopLeftPoint.x() );
mRasterViewPort->mHeight = static_cast<int>( mRasterViewPort->mBottomRightPoint.y() - mRasterViewPort->mTopLeftPoint.y() );
//the drawable area can start to get very very large when you get down displaying 2x2 or smaller, this is because
//mapToPixel.mapUnitsPerPixel() is less then 1,
//so we will just get the pixel data and then render these special cases differently in paintImageToCanvas()
QgsDebugMsgLevel( QStringLiteral( "mapUnitsPerPixel = %1" ).arg( mapToPixel.mapUnitsPerPixel() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mWidth = %1" ).arg( layer->width() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mHeight = %1" ).arg( layer->height() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.xMinimum() = %1" ).arg( myRasterExtent.xMinimum() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.xMaximum() = %1" ).arg( myRasterExtent.xMaximum() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.yMinimum() = %1" ).arg( myRasterExtent.yMinimum() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.yMaximum() = %1" ).arg( myRasterExtent.yMaximum() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mTopLeftPoint.x() = %1" ).arg( mRasterViewPort->mTopLeftPoint.x() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mBottomRightPoint.x() = %1" ).arg( mRasterViewPort->mBottomRightPoint.x() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mTopLeftPoint.y() = %1" ).arg( mRasterViewPort->mTopLeftPoint.y() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mBottomRightPoint.y() = %1" ).arg( mRasterViewPort->mBottomRightPoint.y() ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mWidth = %1" ).arg( mRasterViewPort->mWidth ), 3 );
QgsDebugMsgLevel( QStringLiteral( "mHeight = %1" ).arg( mRasterViewPort->mHeight ), 3 );
// /\/\/\ - added to handle zoomed-in rasters
// TODO R->mLastViewPort = *mRasterViewPort;
// TODO: is it necessary? Probably WMS only?
layer->dataProvider()->setDpi( 25.4 * rendererContext.scaleFactor() );
// copy the whole raster pipe!
mPipe = new QgsRasterPipe( *layer->pipe() );
QgsRasterRenderer *rasterRenderer = mPipe->renderer();
if ( rasterRenderer && !( rendererContext.flags() & QgsRenderContext::RenderPreviewJob ) )
layer->refreshRendererIfNeeded( rasterRenderer, rendererContext.extent() );
}
void FramelessWindow::styleWindow(bool bActive, bool bNoState) {
if (bActive) {
if (bNoState) {
layout()->setMargin(15);
ui->windowTitlebar->setStyleSheet(QStringLiteral(
"#windowTitlebar{border: 0px none palette(shadow); "
"border-top-left-radius:5px; border-top-right-radius:5px; "
"background-color:palette(shadow); height:20px;}"));
ui->windowFrame->setStyleSheet(QStringLiteral(
"#windowFrame{border:1px solid palette(highlight); border-radius:5px "
"5px 5px 5px; background-color:palette(Window);}"));
QGraphicsEffect *oldShadow = ui->windowFrame->graphicsEffect();
if (oldShadow) delete oldShadow;
QGraphicsDropShadowEffect *windowShadow = new QGraphicsDropShadowEffect;
windowShadow->setBlurRadius(9.0);
windowShadow->setColor(palette().color(QPalette::Highlight));
windowShadow->setOffset(0.0);
ui->windowFrame->setGraphicsEffect(windowShadow);
} else {
layout()->setMargin(0);
ui->windowTitlebar->setStyleSheet(QStringLiteral(
"#windowTitlebar{border: 0px none palette(shadow); "
"border-top-left-radius:0px; border-top-right-radius:0px; "
"background-color:palette(shadow); height:20px;}"));
ui->windowFrame->setStyleSheet(QStringLiteral(
"#windowFrame{border:1px solid palette(dark); border-radius:0px 0px "
"0px 0px; background-color:palette(Window);}"));
QGraphicsEffect *oldShadow = ui->windowFrame->graphicsEffect();
if (oldShadow) delete oldShadow;
ui->windowFrame->setGraphicsEffect(nullptr);
} // if (bNoState) else maximize
} else {
if (bNoState) {
layout()->setMargin(15);
ui->windowTitlebar->setStyleSheet(QStringLiteral(
"#windowTitlebar{border: 0px none palette(shadow); "
"border-top-left-radius:5px; border-top-right-radius:5px; "
"background-color:palette(dark); height:20px;}"));
ui->windowFrame->setStyleSheet(QStringLiteral(
"#windowFrame{border:1px solid #000000; border-radius:5px 5px 5px "
"5px; background-color:palette(Window);}"));
QGraphicsEffect *oldShadow = ui->windowFrame->graphicsEffect();
if (oldShadow) delete oldShadow;
QGraphicsDropShadowEffect *windowShadow = new QGraphicsDropShadowEffect;
windowShadow->setBlurRadius(9.0);
windowShadow->setColor(palette().color(QPalette::Shadow));
windowShadow->setOffset(0.0);
ui->windowFrame->setGraphicsEffect(windowShadow);
} else {
layout()->setMargin(0);
ui->windowTitlebar->setStyleSheet(QStringLiteral(
"#titlebarWidget{border: 0px none palette(shadow); "
"border-top-left-radius:0px; border-top-right-radius:0px; "
"background-color:palette(dark); height:20px;}"));
ui->windowFrame->setStyleSheet(QStringLiteral(
"#windowFrame{border:1px solid palette(shadow); border-radius:0px "
"0px 0px 0px; background-color:palette(Window);}"));
QGraphicsEffect *oldShadow = ui->windowFrame->graphicsEffect();
if (oldShadow) delete oldShadow;
ui->windowFrame->setGraphicsEffect(nullptr);
} // if (bNoState) { else maximize
} // if (bActive) { else no focus
}
QgsBookmarks::QgsBookmarks( QWidget *parent )
: QgsDockWidget( parent )
, mQgisModel( nullptr )
, mProjectModel( nullptr )
{
setupUi( this );
restorePosition();
bookmarksDockContents->layout()->setMargin( 0 );
bookmarksDockContents->layout()->setContentsMargins( 0, 0, 0, 0 );
static_cast< QGridLayout* >( bookmarksDockContents->layout() )->setVerticalSpacing( 0 );
QToolButton* btnImpExp = new QToolButton;
btnImpExp->setAutoRaise( true );
btnImpExp->setToolTip( tr( "Import/Export Bookmarks" ) );
btnImpExp->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharing.svg" ) ) );
btnImpExp->setPopupMode( QToolButton::InstantPopup );
QMenu *share = new QMenu( this );
QAction *btnExport = share->addAction( tr( "&Export" ) );
QAction *btnImport = share->addAction( tr( "&Import" ) );
btnExport->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharingExport.svg" ) ) );
btnImport->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharingImport.svg" ) ) );
connect( btnExport, SIGNAL( triggered() ), this, SLOT( exportToXml() ) );
connect( btnImport, SIGNAL( triggered() ), this, SLOT( importFromXml() ) );
btnImpExp->setMenu( share );
connect( actionAdd, SIGNAL( triggered() ), this, SLOT( addClicked() ) );
connect( actionDelete, SIGNAL( triggered() ), this, SLOT( deleteClicked() ) );
connect( actionZoomTo, SIGNAL( triggered() ), this, SLOT( zoomToBookmark() ) );
mBookmarkToolbar->addWidget( btnImpExp );
// open the database
QSqlDatabase db = QSqlDatabase::addDatabase( QStringLiteral( "QSQLITE" ), QStringLiteral( "bookmarks" ) );
db.setDatabaseName( QgsApplication::qgisUserDbFilePath() );
if ( !db.open() )
{
QMessageBox::warning( this, tr( "Error" ),
tr( "Unable to open bookmarks database.\nDatabase: %1\nDriver: %2\nDatabase: %3" )
.arg( QgsApplication::qgisUserDbFilePath(),
db.lastError().driverText(),
db.lastError().databaseText() )
);
deleteLater();
return;
}
mQgisModel = new QSqlTableModel( this, db );
mQgisModel->setTable( QStringLiteral( "tbl_bookmarks" ) );
mQgisModel->setSort( 0, Qt::AscendingOrder );
mQgisModel->select();
mQgisModel->setEditStrategy( QSqlTableModel::OnFieldChange );
// set better headers then column names from table
mQgisModel->setHeaderData( 0, Qt::Horizontal, tr( "ID" ) );
mQgisModel->setHeaderData( 1, Qt::Horizontal, tr( "Name" ) );
mQgisModel->setHeaderData( 2, Qt::Horizontal, tr( "Project" ) );
mQgisModel->setHeaderData( 3, Qt::Horizontal, tr( "xMin" ) );
mQgisModel->setHeaderData( 4, Qt::Horizontal, tr( "yMin" ) );
mQgisModel->setHeaderData( 5, Qt::Horizontal, tr( "xMax" ) );
mQgisModel->setHeaderData( 6, Qt::Horizontal, tr( "yMax" ) );
mQgisModel->setHeaderData( 7, Qt::Horizontal, tr( "SRID" ) );
mProjectModel = new QgsProjectBookmarksTableModel();
mModel.reset( new QgsMergedBookmarksTableModel( *mQgisModel, *mProjectModel, lstBookmarks ) );
lstBookmarks->setModel( mModel.data() );
QSettings settings;
lstBookmarks->header()->restoreState( settings.value( QStringLiteral( "/Windows/Bookmarks/headerstate" ) ).toByteArray() );
#ifndef QGISDEBUG
lstBookmarks->setColumnHidden( 0, true );
#endif
}
bool luks::unmount(const QString& deviceNode)
{
ExternalCommand cmd(QStringLiteral("cryptsetup"), QStringList() << QStringLiteral("luksClose") << mapperName(deviceNode));
return cmd.run(-1) && cmd.exitCode() == 0;
}
void QgsRasterCalcDialog::mOrButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " OR " ) );
}
void QgsBookmarks::restorePosition()
{
QSettings settings;
restoreGeometry( settings.value( QStringLiteral( "/Windows/Bookmarks/geometry" ) ).toByteArray() );
}
/*!
* Add a hightlight rule with the given \a type, \a formula1, \a formula2,
* \a format and \a stopIfTrue.
* Return false if failed.
*/
bool ConditionalFormatting::addHighlightCellsRule(HighlightRuleType type, const QString &formula1, const QString &formula2, const Format &format, bool stopIfTrue)
{
if (format.isEmpty())
return false;
bool skipFormula = false;
QSharedPointer<XlsxCfRuleData> cfRule(new XlsxCfRuleData);
if (type >= Highlight_LessThan && type <= Highlight_NotBetween) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("cellIs");
QString op;
switch (type) {
case Highlight_Between: op = QStringLiteral("between"); break;
case Highlight_Equal: op = QStringLiteral("equal"); break;
case Highlight_GreaterThan: op = QStringLiteral("greaterThan"); break;
case Highlight_GreaterThanOrEqual: op = QStringLiteral("greaterThanOrEqual"); break;
case Highlight_LessThan: op = QStringLiteral("lessThan"); break;
case Highlight_LessThanOrEqual: op = QStringLiteral("lessThanOrEqual"); break;
case Highlight_NotBetween: op = QStringLiteral("notBetween"); break;
case Highlight_NotEqual: op = QStringLiteral("notEqual"); break;
default: break;
}
cfRule->attrs[XlsxCfRuleData::A_operator] = op;
} else if (type >= Highlight_ContainsText && type <= Highlight_EndsWith) {
if (type == Highlight_ContainsText) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("containsText");
cfRule->attrs[XlsxCfRuleData::A_operator] = QStringLiteral("containsText");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("NOT(ISERROR(SEARCH(\"%1\",%2)))").arg(formula1);
} else if (type == Highlight_NotContainsText) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("notContainsText");
cfRule->attrs[XlsxCfRuleData::A_operator] = QStringLiteral("notContains");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("ISERROR(SEARCH(\"%2\",%1))").arg(formula1);
} else if (type == Highlight_BeginsWith) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("beginsWith");
cfRule->attrs[XlsxCfRuleData::A_operator] = QStringLiteral("beginsWith");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("LEFT(%2,LEN(\"%1\"))=\"%1\"").arg(formula1);
} else {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("endsWith");
cfRule->attrs[XlsxCfRuleData::A_operator] = QStringLiteral("endsWith");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("RIGHT(%2,LEN(\"%1\"))=\"%1\"").arg(formula1);
}
cfRule->attrs[XlsxCfRuleData::A_text] = formula1;
skipFormula = true;
} else if (type == Highlight_TimePeriod) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("timePeriod");
//:Todo
return false;
} else if (type == Highlight_Duplicate) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("duplicateValues");
} else if (type == Highlight_Unique) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("uniqueValues");
} else if (type == Highlight_Errors) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("containsErrors");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("ISERROR(%1)");
skipFormula = true;
} else if (type == Highlight_NoErrors) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("notContainsErrors");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("NOT(ISERROR(%1))");
skipFormula = true;
} else if (type == Highlight_Blanks) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("containsBlanks");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("LEN(TRIM(%1))=0");
skipFormula = true;
} else if (type == Highlight_NoBlanks) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("notContainsBlanks");
cfRule->attrs[XlsxCfRuleData::A_formula1_temp] = QStringLiteral("LEN(TRIM(%1))>0");
skipFormula = true;
} else if (type >= Highlight_Top && type <= Highlight_BottomPercent) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("top10");
if (type == Highlight_Bottom || type == Highlight_BottomPercent)
cfRule->attrs[XlsxCfRuleData::A_bottom] = QStringLiteral("1");
if (type == Highlight_TopPercent || type == Highlight_BottomPercent)
cfRule->attrs[XlsxCfRuleData::A_percent] = QStringLiteral("1");
cfRule->attrs[XlsxCfRuleData::A_rank] = !formula1.isEmpty() ? formula1 : QStringLiteral("10");
skipFormula = true;
} else if (type >= Highlight_AboveAverage && type <= Highlight_BelowStdDev3) {
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("aboveAverage");
if (type >= Highlight_BelowAverage && type <= Highlight_BelowStdDev3)
cfRule->attrs[XlsxCfRuleData::A_aboveAverage] = QStringLiteral("0");
if (type == Highlight_AboveOrEqualAverage || type == Highlight_BelowOrEqualAverage)
cfRule->attrs[XlsxCfRuleData::A_equalAverage] = QStringLiteral("1");
if (type == Highlight_AboveStdDev1 || type == Highlight_BelowStdDev1)
cfRule->attrs[XlsxCfRuleData::A_stdDev] = QStringLiteral("1");
else if (type == Highlight_AboveStdDev2 || type == Highlight_BelowStdDev2)
cfRule->attrs[XlsxCfRuleData::A_stdDev] = QStringLiteral("2");
else if (type == Highlight_AboveStdDev3 || type == Highlight_BelowStdDev3)
cfRule->attrs[XlsxCfRuleData::A_stdDev] = QStringLiteral("3");
} else if (type == Highlight_Expression){
cfRule->attrs[XlsxCfRuleData::A_type] = QStringLiteral("expression");
} else {
return false;
}
cfRule->dxfFormat = format;
if (stopIfTrue)
cfRule->attrs[XlsxCfRuleData::A_stopIfTrue] = true;
if (!skipFormula) {
if (!formula1.isEmpty())
cfRule->attrs[XlsxCfRuleData::A_formula1] = formula1.startsWith(QLatin1String("=")) ? formula1.mid(1) : formula1;
if (!formula2.isEmpty())
cfRule->attrs[XlsxCfRuleData::A_formula2] = formula2.startsWith(QLatin1String("=")) ? formula2.mid(1) : formula2;
}
d->cfRules.append(cfRule);
return true;
}
/*!
* \overload
* Add a dataBar rule with the given \a color, \a showData and \a stopIfTrue.
*/
bool ConditionalFormatting::addDataBarRule(const QColor &color, bool showData, bool stopIfTrue)
{
return addDataBarRule(color, VOT_Min, QStringLiteral("0"), VOT_Max, QStringLiteral("0"), showData, stopIfTrue);
}
void CodeGenerator::writeCoreFactoryImplementation(const QString &fileName) const
{
if (!m_parser)
return;
QFile file(fileName);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream stream(&file);
// Write the preamble
writePreamble(fileName, stream);
// Get the set of version functions classes we need to create
QList<Version> versions = m_parser->versions();
qSort(versions.begin(), versions.end(), qGreater<Version>());
// Outout the #include statements
stream << QStringLiteral("#if !defined(QT_OPENGL_ES_2)") << endl;
Q_FOREACH (const Version &classVersion, versions) {
if (!versionHasProfiles(classVersion)) {
stream << QString(QStringLiteral("#include \"qopenglfunctions_%1_%2.h\""))
.arg(classVersion.major)
.arg(classVersion.minor) << endl;
} else {
const QList<VersionProfile::OpenGLProfile> profiles = (QList<VersionProfile::OpenGLProfile>()
<< VersionProfile::CoreProfile << VersionProfile::CompatibilityProfile);
Q_FOREACH (const VersionProfile::OpenGLProfile profile, profiles) {
const QString profileSuffix = profile == VersionProfile::CoreProfile
? QStringLiteral("core")
: QStringLiteral("compatibility");
stream << QString(QStringLiteral("#include \"qopenglfunctions_%1_%2_%3.h\""))
.arg(classVersion.major)
.arg(classVersion.minor)
.arg(profileSuffix) << endl;
}
}
}
stream << QStringLiteral("#else") << endl;
stream << QStringLiteral("#include \"qopenglfunctions_es2.h\"") << endl;
stream << QStringLiteral("#endif") << endl;
stream << endl;
stream << QStringLiteral("QT_BEGIN_NAMESPACE") << endl << endl;
stream << QStringLiteral("QAbstractOpenGLFunctions *QOpenGLVersionFunctionsFactory::create(const QOpenGLVersionProfile &versionProfile)") << endl;
stream << QStringLiteral("{") << endl;
stream << QStringLiteral("#if !defined(QT_OPENGL_ES_2)") << endl;
stream << QStringLiteral(" const int major = versionProfile.version().first;") << endl;
stream << QStringLiteral(" const int minor = versionProfile.version().second;") << endl << endl;
// Iterate over classes with profiles
stream << QStringLiteral(" if (versionProfile.hasProfiles()) {") << endl;
stream << QStringLiteral(" switch (versionProfile.profile()) {") << endl;
const QList<VersionProfile::OpenGLProfile> profiles = (QList<VersionProfile::OpenGLProfile>()
<< VersionProfile::CoreProfile << VersionProfile::CompatibilityProfile);
Q_FOREACH (const VersionProfile::OpenGLProfile profile, profiles) {
const QString caseLabel = profile == VersionProfile::CoreProfile
? QStringLiteral("QSurfaceFormat::CoreProfile")
: QStringLiteral("QSurfaceFormat::CompatibilityProfile");
stream << QString(QStringLiteral(" case %1:")).arg(caseLabel) << endl;
int i = 0;
Q_FOREACH (const Version &classVersion, versions) {
if (!versionHasProfiles(classVersion))
continue;
const QString ifString = (i++ == 0) ? QStringLiteral("if") : QStringLiteral("else if");
stream << QString(QStringLiteral(" %1 (major == %2 && minor == %3)"))
.arg(ifString)
.arg(classVersion.major)
.arg(classVersion.minor) << endl;
VersionProfile v;
v.version = classVersion;
v.profile = profile;
stream << QString(QStringLiteral(" return new %1;"))
.arg(generateClassName(v)) << endl;
}
stream << QStringLiteral(" break;") << endl << endl;
}
stream << QStringLiteral(" case QSurfaceFormat::NoProfile:") << endl;
stream << QStringLiteral(" default:") << endl;
stream << QStringLiteral(" break;") << endl;
stream << QStringLiteral(" };") << endl;
stream << QStringLiteral(" } else {") << endl;
// Iterate over the legacy classes (no profiles)
int i = 0;
Q_FOREACH (const Version &classVersion, versions) {
if (versionHasProfiles(classVersion))
continue;
const QString ifString = (i++ == 0) ? QStringLiteral("if") : QStringLiteral("else if");
stream << QString(QStringLiteral(" %1 (major == %2 && minor == %3)"))
.arg(ifString)
.arg(classVersion.major)
.arg(classVersion.minor) << endl;
VersionProfile v;
v.version = classVersion;
stream << QString(QStringLiteral(" return new %1;"))
.arg(generateClassName(v)) << endl;
}
stream << QStringLiteral(" }") << endl;
stream << QStringLiteral(" return 0;") << endl;
stream << QStringLiteral("#else") << endl;
stream << QStringLiteral(" Q_UNUSED(versionProfile);") << endl;
stream << QStringLiteral(" return new QOpenGLFunctions_ES2;") << endl;
stream << QStringLiteral("#endif") << endl;
stream << QStringLiteral("}") << endl;
// Write the postamble
writePostamble(fileName, stream);
}
void CodeGenerator::generateExtensionClasses(const QString &baseFileName) const
{
writeExtensionHeader(baseFileName + QStringLiteral(".h"));
writeExtensionImplementation(baseFileName + QStringLiteral(".cpp"));
}
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "codegenerator.h"
#include <QDebug>
#include <QFile>
#include <QSettings>
#include <QTextStream>
static const QString extensionRegistryFileName = QStringLiteral("qopengl-extension-registry.ini");
static const QString extensionIdGroupName = QStringLiteral("ExtensionIds");
CodeGenerator::CodeGenerator()
: m_parser(0)
{
}
void CodeGenerator::generateCoreClasses(const QString &baseFileName) const
{
// Output header and implementation files for the backend and base class
writeCoreHelperClasses(baseFileName + QStringLiteral(".h"), Declaration);
writeCoreHelperClasses(baseFileName + QStringLiteral(".cpp"), Definition);
// Output the per-version and profile public classes
writeCoreClasses(baseFileName);
void MainView::displayUsers() {
QQmlComponent component(engineApp);
component.loadUrl(QUrl(QStringLiteral("qrc:/views/users.qml")));
if (component.isReady())
component.create();
}
void MainView::openCapture(){
QQmlComponent component(engineApp);
component.loadUrl(QUrl(QStringLiteral("qrc:/views/openPcap.qml")));
if (component.isReady())
component.create();
}
void QgsRasterCalcDialog::mCloseBracketPushButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " ) " ) );
}
bool ConditionalFormattingPrivate::readCfRule(QXmlStreamReader &reader, XlsxCfRuleData *rule, Styles *styles)
{
Q_ASSERT(reader.name() == QLatin1String("cfRule"));
QXmlStreamAttributes attrs = reader.attributes();
if (attrs.hasAttribute(QLatin1String("type")))
rule->attrs[XlsxCfRuleData::A_type] = attrs.value(QLatin1String("type")).toString();
if (attrs.hasAttribute(QLatin1String("dxfId"))) {
int id = attrs.value(QLatin1String("dxfId")).toString().toInt();
if (styles)
rule->dxfFormat = styles->dxfFormat(id);
else
rule->dxfFormat.setDxfIndex(id);
}
rule->priority = attrs.value(QLatin1String("priority")).toString().toInt();
if (attrs.value(QLatin1String("stopIfTrue")) == QLatin1String("1")) {
//default is false
rule->attrs[XlsxCfRuleData::A_stopIfTrue] = QLatin1String("1");
}
if (attrs.value(QLatin1String("aboveAverage")) == QLatin1String("0")) {
//default is true
rule->attrs[XlsxCfRuleData::A_aboveAverage] = QLatin1String("0");
}
if (attrs.value(QLatin1String("percent")) == QLatin1String("1")) {
//default is false
rule->attrs[XlsxCfRuleData::A_percent] = QLatin1String("1");
}
if (attrs.value(QLatin1String("bottom")) == QLatin1String("1")) {
//default is false
rule->attrs[XlsxCfRuleData::A_bottom] = QLatin1String("1");
}
if (attrs.hasAttribute(QLatin1String("operator")))
rule->attrs[XlsxCfRuleData::A_operator] = attrs.value(QLatin1String("operator")).toString();
if (attrs.hasAttribute(QLatin1String("text")))
rule->attrs[XlsxCfRuleData::A_text] = attrs.value(QLatin1String("text")).toString();
if (attrs.hasAttribute(QLatin1String("timePeriod")))
rule->attrs[XlsxCfRuleData::A_timePeriod] = attrs.value(QLatin1String("timePeriod")).toString();
if (attrs.hasAttribute(QLatin1String("rank")))
rule->attrs[XlsxCfRuleData::A_rank] = attrs.value(QLatin1String("rank")).toString();
if (attrs.hasAttribute(QLatin1String("stdDev")))
rule->attrs[XlsxCfRuleData::A_stdDev] = attrs.value(QLatin1String("stdDev")).toString();
if (attrs.value(QLatin1String("equalAverage")) == QLatin1String("1")) {
//default is false
rule->attrs[XlsxCfRuleData::A_equalAverage] = QLatin1String("1");
}
while (!reader.atEnd()) {
reader.readNextStartElement();
if (reader.tokenType() == QXmlStreamReader::StartElement) {
if (reader.name() == QLatin1String("formula")) {
QString f = reader.readElementText();
if (!rule->attrs.contains(XlsxCfRuleData::A_formula1))
rule->attrs[XlsxCfRuleData::A_formula1] = f;
else if (!rule->attrs.contains(XlsxCfRuleData::A_formula2))
rule->attrs[XlsxCfRuleData::A_formula2] = f;
else if (!rule->attrs.contains(XlsxCfRuleData::A_formula3))
rule->attrs[XlsxCfRuleData::A_formula3] = f;
} else if (reader.name() == QLatin1String("dataBar")) {
readCfDataBar(reader, rule);
} else if (reader.name() == QLatin1String("colorScale")) {
readCfColorScale(reader, rule);
}
}
if (reader.tokenType() == QXmlStreamReader::EndElement
&& reader.name() == QStringLiteral("conditionalFormatting")) {
break;
}
}
return true;
}
void QgsRasterCalcDialog::mGreaterEqualButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " >= " ) );
}
void ConditionalFormattingPrivate::writeCfVo(QXmlStreamWriter &writer, const XlsxCfVoData &cfvo) const
{
writer.writeEmptyElement(QStringLiteral("cfvo"));
QString type;
switch(cfvo.type) {
case ConditionalFormatting::VOT_Formula: type=QStringLiteral("formula"); break;
case ConditionalFormatting::VOT_Max: type=QStringLiteral("max"); break;
case ConditionalFormatting::VOT_Min: type=QStringLiteral("min"); break;
case ConditionalFormatting::VOT_Num: type=QStringLiteral("num"); break;
case ConditionalFormatting::VOT_Percent: type=QStringLiteral("percent"); break;
case ConditionalFormatting::VOT_Percentile: type=QStringLiteral("percentile"); break;
default: break;
}
writer.writeAttribute(QStringLiteral("type"), type);
writer.writeAttribute(QStringLiteral("val"), cfvo.value);
if (!cfvo.gte)
writer.writeAttribute(QStringLiteral("gte"), QStringLiteral("0"));
}
void OpenGLVideo::setOpenGLContext(QOpenGLContext *ctx)
{
DPTR_D(OpenGLVideo);
if (d.ctx == ctx)
return;
d.resetGL(); //TODO: is it ok to destroygl resources in another context?
d.ctx = ctx; // Qt4: set to null in resetGL()
if (!ctx) {
return;
}
if (d.material)
delete d.material;
d.material = new VideoMaterial();
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
d.manager = ctx->findChild<ShaderManager*>(QStringLiteral("__qtav_shader_manager"));
QSizeF surfaceSize = ctx->surface()->size();
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
surfaceSize *= ctx->screen()->devicePixelRatio();
#else
surfaceSize *= qApp->devicePixelRatio(); //TODO: window()->devicePixelRatio() is the window screen's
#endif
#else
QSizeF surfaceSize = QSizeF(ctx->device()->width(), ctx->device()->height());
#endif
setProjectionMatrixToRect(QRectF(QPointF(), surfaceSize));
if (d.manager)
return;
// TODO: what if ctx is delete?
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
d.manager = new ShaderManager(ctx);
QObject::connect(ctx, SIGNAL(aboutToBeDestroyed()), this, SLOT(resetGL()), Qt::DirectConnection); //direct?
#else
d.manager = new ShaderManager(this);
#endif
d.manager->setObjectName(QStringLiteral("__qtav_shader_manager"));
/// get gl info here because context is current(qt ensure it)
//const QByteArray extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)));
bool hasGLSL = QOpenGLShaderProgram::hasOpenGLShaderPrograms();
qDebug("OpenGL version: %d.%d hasGLSL: %d", ctx->format().majorVersion(), ctx->format().minorVersion(), hasGLSL);
static bool sInfo = true;
if (sInfo) {
sInfo = false;
qDebug("GL_VERSION: %s", DYGL(glGetString(GL_VERSION)));
qDebug("GL_VENDOR: %s", DYGL(glGetString(GL_VENDOR)));
qDebug("GL_RENDERER: %s", DYGL(glGetString(GL_RENDERER)));
qDebug("GL_SHADING_LANGUAGE_VERSION: %s", DYGL(glGetString(GL_SHADING_LANGUAGE_VERSION)));
/// check here with current context can ensure the right result. If the first check is in VideoShader/VideoMaterial/decoder or somewhere else, the context can be null
bool v = OpenGLHelper::isOpenGLES();
qDebug("Is OpenGLES: %d", v);
v = OpenGLHelper::isEGL();
qDebug("Is EGL: %d", v);
const int glsl_ver = OpenGLHelper::GLSLVersion();
qDebug("GLSL version: %d", glsl_ver);
v = OpenGLHelper::isPBOSupported();
qDebug("Has PBO: %d", v);
v = OpenGLHelper::has16BitTexture();
qDebug("Has 16bit texture: %d", v);
v = OpenGLHelper::hasRG();
qDebug("Has RG texture: %d", v);
qDebug() << ctx->format();
}
}
bool ConditionalFormatting::saveToXml(QXmlStreamWriter &writer) const
{
writer.writeStartElement(QStringLiteral("conditionalFormatting"));
QStringList sqref;
foreach (CellRange range, ranges())
sqref.append(range.toString());
writer.writeAttribute(QStringLiteral("sqref"), sqref.join(QLatin1Char(' ')));
for (int i=0; i<d->cfRules.size(); ++i) {
const QSharedPointer<XlsxCfRuleData> &rule = d->cfRules[i];
writer.writeStartElement(QStringLiteral("cfRule"));
writer.writeAttribute(QStringLiteral("type"), rule->attrs[XlsxCfRuleData::A_type].toString());
if (rule->dxfFormat.dxfIndexValid())
writer.writeAttribute(QStringLiteral("dxfId"), QString::number(rule->dxfFormat.dxfIndex()));
writer.writeAttribute(QStringLiteral("priority"), QString::number(rule->priority));
if (rule->attrs.contains(XlsxCfRuleData::A_stopIfTrue))
writer.writeAttribute(QStringLiteral("stopIfTrue"), rule->attrs[XlsxCfRuleData::A_stopIfTrue].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_aboveAverage))
writer.writeAttribute(QStringLiteral("aboveAverage"), rule->attrs[XlsxCfRuleData::A_aboveAverage].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_percent))
writer.writeAttribute(QStringLiteral("percent"), rule->attrs[XlsxCfRuleData::A_percent].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_bottom))
writer.writeAttribute(QStringLiteral("bottom"), rule->attrs[XlsxCfRuleData::A_bottom].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_operator))
writer.writeAttribute(QStringLiteral("operator"), rule->attrs[XlsxCfRuleData::A_operator].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_text))
writer.writeAttribute(QStringLiteral("text"), rule->attrs[XlsxCfRuleData::A_text].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_timePeriod))
writer.writeAttribute(QStringLiteral("timePeriod"), rule->attrs[XlsxCfRuleData::A_timePeriod].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_rank))
writer.writeAttribute(QStringLiteral("rank"), rule->attrs[XlsxCfRuleData::A_rank].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_stdDev))
writer.writeAttribute(QStringLiteral("stdDev"), rule->attrs[XlsxCfRuleData::A_stdDev].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_equalAverage))
writer.writeAttribute(QStringLiteral("equalAverage"), rule->attrs[XlsxCfRuleData::A_equalAverage].toString());
if (rule->attrs[XlsxCfRuleData::A_type] == QLatin1String("dataBar")) {
writer.writeStartElement(QStringLiteral("dataBar"));
if (rule->attrs.contains(XlsxCfRuleData::A_hideData))
writer.writeAttribute(QStringLiteral("showValue"), QStringLiteral("0"));
d->writeCfVo(writer, rule->attrs[XlsxCfRuleData::A_cfvo1].value<XlsxCfVoData>());
d->writeCfVo(writer, rule->attrs[XlsxCfRuleData::A_cfvo2].value<XlsxCfVoData>());
rule->attrs[XlsxCfRuleData::A_color1].value<XlsxColor>().saveToXml(writer);
writer.writeEndElement();//dataBar
} else if (rule->attrs[XlsxCfRuleData::A_type] == QLatin1String("colorScale")) {
writer.writeStartElement(QStringLiteral("colorScale"));
d->writeCfVo(writer, rule->attrs[XlsxCfRuleData::A_cfvo1].value<XlsxCfVoData>());
d->writeCfVo(writer, rule->attrs[XlsxCfRuleData::A_cfvo2].value<XlsxCfVoData>());
if (rule->attrs.contains(XlsxCfRuleData::A_cfvo3))
d->writeCfVo(writer, rule->attrs[XlsxCfRuleData::A_cfvo3].value<XlsxCfVoData>());
rule->attrs[XlsxCfRuleData::A_color1].value<XlsxColor>().saveToXml(writer);
rule->attrs[XlsxCfRuleData::A_color2].value<XlsxColor>().saveToXml(writer);
if (rule->attrs.contains(XlsxCfRuleData::A_color3))
rule->attrs[XlsxCfRuleData::A_color3].value<XlsxColor>().saveToXml(writer);
writer.writeEndElement();//colorScale
}
if (rule->attrs.contains(XlsxCfRuleData::A_formula1_temp)) {
QString startCell = ranges()[0].toString().split(QLatin1Char(':'))[0];
writer.writeTextElement(QStringLiteral("formula"), rule->attrs[XlsxCfRuleData::A_formula1_temp].toString().arg(startCell));
} else if (rule->attrs.contains(XlsxCfRuleData::A_formula1)) {
writer.writeTextElement(QStringLiteral("formula"), rule->attrs[XlsxCfRuleData::A_formula1].toString());
}
if (rule->attrs.contains(XlsxCfRuleData::A_formula2))
writer.writeTextElement(QStringLiteral("formula"), rule->attrs[XlsxCfRuleData::A_formula2].toString());
if (rule->attrs.contains(XlsxCfRuleData::A_formula3))
writer.writeTextElement(QStringLiteral("formula"), rule->attrs[XlsxCfRuleData::A_formula3].toString());
writer.writeEndElement(); //cfRule
}
writer.writeEndElement(); //conditionalFormatting
return true;
}
void QgsBookmarks::saveWindowLocation()
{
QSettings settings;
settings.setValue( QStringLiteral( "/Windows/Bookmarks/geometry" ), saveGeometry() );
settings.setValue( QStringLiteral( "/Windows/Bookmarks/headerstate" ), lstBookmarks->header()->saveState() );
}
void QgsRasterCalcDialog::showHelp()
{
QgsHelp::openHelp( QStringLiteral( "working_with_raster/raster_analysis.html#raster-calculator" ) );
}
FileSystem::SupportTool luks::supportToolName() const
{
return SupportTool(QStringLiteral("cryptsetup"), QUrl(QStringLiteral("https://code.google.com/p/cryptsetup/")));
}
void QgsRasterCalcDialog::mMultiplyPushButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " * " ) );
}
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//*****************************************************************************
#define _USE_MATH_DEFINES
#include "audiomixer.h"
#include "audioinput.h"
#include "application.h"
#include "profile.h"
#include <QtCore/QBuffer>
const QString LOG_CAT = QStringLiteral("Audio");
//=============================================================================
// Helpers
/// <summary>
/// Loops `num` within the range [0..`max`) (0.0 to just below `max`).
/// Negative numbers are not inverted, i.e. "-0.1" becomes "`max` - 0.1".
/// </summary>
double dblRepeat(double num, double max)
{
double tmp;
tmp = num - (double)((int)(num / max)) * max;
if(tmp < 0.0)
return max + tmp;
return tmp;
void QgsRasterCalcDialog::mDividePushButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " / " ) );
}
void QgsTextEditConfigDlg::setConfig( const QgsEditorWidgetConfig& config )
{
mIsMultiline->setChecked( config.value( QStringLiteral( "IsMultiline" ) ).toBool() );
mUseHtml->setChecked( config.value( QStringLiteral( "UseHtml" ) ).toBool() );
}
void QgsRasterCalcDialog::mCosButton_clicked()
{
mExpressionTextEdit->insertPlainText( QStringLiteral( " std::cos ( " ) );
}
void QQuickWebEngineView::loadHtml(const QString &html, const QUrl &baseUrl)
{
Q_D(QQuickWebEngineView);
d->adapter->setContent(html.toUtf8(), QStringLiteral("text/html;charset=UTF-8"), baseUrl);
}
void QQuickOpenGLShaderEffectCommon::updateShader(QQuickItem *item,
const QMetaObject *itemMetaObject,
Key::ShaderType shaderType)
{
disconnectPropertySignals(item, shaderType);
uniformData[shaderType].clear();
clearSignalMappers(shaderType);
if (shaderType == Key::VertexShader)
attributes.clear();
// A qrc or file URL means the shader source is to be read from the specified file.
QUrl srcUrl(QString::fromUtf8(source.sourceCode[shaderType]));
if (!srcUrl.scheme().compare(QLatin1String("qrc"), Qt::CaseInsensitive) || srcUrl.isLocalFile()) {
if (!fileSelector) {
fileSelector = new QFileSelector(item);
// There may not be an OpenGL context accessible here. So rely on
// the window's requestedFormat().
if (item->window()
&& item->window()->requestedFormat().profile() == QSurfaceFormat::CoreProfile) {
fileSelector->setExtraSelectors(QStringList() << QStringLiteral("glslcore"));
}
}
const QString fn = fileSelector->select(QQmlFile::urlToLocalFileOrQrc(srcUrl));
QFile f(fn);
if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
source.sourceCode[shaderType] = f.readAll();
f.close();
} else {
qWarning("ShaderEffect: Failed to read %s", qPrintable(fn));
source.sourceCode[shaderType] = QByteArray();
}
}
const QByteArray &code = source.sourceCode[shaderType];
if (code.isEmpty()) {
// Optimize for default code.
if (shaderType == Key::VertexShader) {
attributes.append(QByteArray(qtPositionAttributeName()));
attributes.append(QByteArray(qtTexCoordAttributeName()));
UniformData d;
d.name = "qt_Matrix";
d.specialType = UniformData::Matrix;
uniformData[Key::VertexShader].append(d);
signalMappers[Key::VertexShader].append(0);
} else if (shaderType == Key::FragmentShader) {
UniformData d;
d.name = "qt_Opacity";
d.specialType = UniformData::Opacity;
uniformData[Key::FragmentShader].append(d);
signalMappers[Key::FragmentShader].append(0);
const int mappedId = 1 | (Key::FragmentShader << 16);
auto mapper = new QtPrivate::MappedSlotObject([this, mappedId](){mappedPropertyChanged(mappedId);});
const char *sourceName = "source";
d.name = sourceName;
d.setValueFromProperty(item, itemMetaObject);
d.specialType = UniformData::Sampler;
uniformData[Key::FragmentShader].append(d);
signalMappers[Key::FragmentShader].append(mapper);
}
} else {
lookThroughShaderCode(item, itemMetaObject, shaderType, code);
}
connectPropertySignals(item, itemMetaObject, shaderType);
}