bool QgsGplColorScheme::setColors( const QgsNamedColorList &colors, const QString &context, const QColor &baseColor ) { Q_UNUSED( context ); Q_UNUSED( baseColor ); QString destFilePath = gplFilePath(); if ( destFilePath.isEmpty() ) { return false; } QFile destFile( destFilePath ); if ( QgsSymbolLayerUtils::saveColorsToGpl( destFile, schemeName(), colors ) ) { if ( QgsApplication::colorSchemeRegistry()->randomStyleColorScheme() == this ) { // force a re-generation of the random style color list, since the color list has changed QgsApplication::colorSchemeRegistry()->setRandomStyleColorScheme( this ); } return true; } else { return false; } }
tmp<convectionScheme<Type> > convectionScheme<Type>::New ( const fvMesh& mesh, const typename multivariateSurfaceInterpolationScheme<Type>:: fieldTable& fields, const surfaceScalarField& faceFlux, Istream& schemeData ) { if (fv::debug) { Info<< "convectionScheme<Type>::New" "(const fvMesh&, " "const typename multivariateSurfaceInterpolationScheme<Type>" "::fieldTable&, const surfaceScalarField&, Istream&) : " "constructing convectionScheme<Type>" << endl; } if (schemeData.eof()) { FatalIOErrorIn ( "convectionScheme<Type>::New" "(const fvMesh&, " "const typename multivariateSurfaceInterpolationScheme<Type>" "::fieldTable&, const surfaceScalarField&, Istream&)", schemeData ) << "Convection scheme not specified" << endl << endl << "Valid convection schemes are :" << endl << MultivariateConstructorTablePtr_->sortedToc() << exit(FatalIOError); } word schemeName(schemeData); typename MultivariateConstructorTable::iterator cstrIter = MultivariateConstructorTablePtr_->find(schemeName); if (cstrIter == MultivariateConstructorTablePtr_->end()) { FatalIOErrorIn ( "convectionScheme<Type>::New" "(const fvMesh&, " "const typename multivariateSurfaceInterpolationScheme<Type>" "::fieldTable&, const surfaceScalarField&, Istream&)", schemeData ) << "unknown convection scheme " << schemeName << endl << endl << "Valid convection schemes are :" << endl << MultivariateConstructorTablePtr_->sortedToc() << exit(FatalIOError); } return cstrIter()(mesh, fields, faceFlux, schemeData); }
tmp<limitedSurfaceInterpolationScheme<Type> > limitedSurfaceInterpolationScheme<Type>::New ( const fvMesh& mesh, const surfaceScalarField& faceFlux, Istream& schemeData ) { if (surfaceInterpolation::debug) { Info<< "limitedSurfaceInterpolationScheme<Type>::New" "(const fvMesh&, const surfaceScalarField&, Istream&) : " "constructing limitedSurfaceInterpolationScheme<Type>" << endl; } if (schemeData.eof()) { FatalIOErrorIn ( "limitedSurfaceInterpolationScheme<Type>::New" "(const fvMesh&, const surfaceScalarField&, Istream&)", schemeData ) << "Discretisation scheme not specified" << endl << endl << "Valid schemes are :" << endl << MeshConstructorTablePtr_->sortedToc() << exit(FatalIOError); } word schemeName(schemeData); typename MeshFluxConstructorTable::iterator constructorIter = MeshFluxConstructorTablePtr_->find(schemeName); if (constructorIter == MeshFluxConstructorTablePtr_->end()) { FatalIOErrorIn ( "limitedSurfaceInterpolationScheme<Type>::New" "(const fvMesh&, const surfaceScalarField&, Istream&)", schemeData ) << "Unknown discretisation scheme " << schemeName << endl << endl << "Valid schemes are :" << endl << MeshFluxConstructorTablePtr_->sortedToc() << exit(FatalIOError); } return constructorIter()(mesh, faceFlux, schemeData); }
tmp<lnGradScheme<Type> > lnGradScheme<Type>::New ( const faMesh& mesh, Istream& schemeData ) { if (fa::debug) { Info<< "lnGradScheme<Type>::New(const faMesh&, Istream&)" " : constructing lnGradScheme<Type>" << endl; } if (schemeData.eof()) { FatalIOErrorIn ( "lnGradScheme<Type>::New(const faMesh&, Istream&)", schemeData ) << "Discretisation scheme not specified" << endl << endl << "Valid schemes are :" << endl << MeshConstructorTablePtr_->toc() << exit(FatalIOError); } word schemeName(schemeData); typename MeshConstructorTable::iterator constructorIter = MeshConstructorTablePtr_->find(schemeName); if (constructorIter == MeshConstructorTablePtr_->end()) { FatalIOErrorIn ( "lnGradScheme<Type>::New(const faMesh&, Istream&)", schemeData ) << "Unknown discretisation scheme " << schemeName << endl << endl << "Valid schemes are :" << endl << MeshConstructorTablePtr_->toc() << exit(FatalIOError); } return constructorIter()(mesh, schemeData); }
tmp<divScheme<Type> > divScheme<Type>::New ( const faMesh& mesh, Istream& schemeData ) { if (fa::debug) { Info<< "divScheme<Type>::New(const faMesh&, Istream&) : " "constructing divScheme<Type>" << endl; } if (schemeData.eof()) { FatalIOErrorIn ( "divScheme<Type>::New(const faMesh&, Istream&)", schemeData ) << "Div scheme not specified" << endl << endl << "Valid div schemes are :" << endl << IstreamConstructorTablePtr_->sortedToc() << exit(FatalIOError); } word schemeName(schemeData); typename IstreamConstructorTable::iterator cstrIter = IstreamConstructorTablePtr_->find(schemeName); if (cstrIter == IstreamConstructorTablePtr_->end()) { FatalIOErrorIn ( "divScheme<Type>::New(const faMesh&, Istream&)", schemeData ) << "unknown div scheme " << schemeName << endl << endl << "Valid div schemes are :" << endl << IstreamConstructorTablePtr_->sortedToc() << exit(FatalIOError); } return cstrIter()(mesh, schemeData); }
tmp<laplacianScheme<Type, GType> > laplacianScheme<Type, GType>::New ( const fvMesh& mesh, Istream& schemeData ) { if (fv::debug) { Info<< "laplacianScheme<Type, GType>::New(const fvMesh&, Istream&) : " "constructing laplacianScheme<Type, GType>" << endl; } if (schemeData.eof()) { FatalIOErrorIn ( "laplacianScheme<Type, GType>::New(const fvMesh&, Istream&)", schemeData ) << "Laplacian scheme not specified" << endl << endl << "Valid laplacian schemes are :" << endl << IstreamConstructorTablePtr_->toc() << exit(FatalIOError); } word schemeName(schemeData); typename IstreamConstructorTable::iterator cstrIter = IstreamConstructorTablePtr_->find(schemeName); if (cstrIter == IstreamConstructorTablePtr_->end()) { FatalIOErrorIn ( "laplacianScheme<Type, GType>::New(const fvMesh&, Istream&)", schemeData ) << "unknown laplacian scheme " << schemeName << endl << endl << "Valid laplacian schemes are :" << endl << IstreamConstructorTablePtr_->toc() << exit(FatalIOError); } return cstrIter()(mesh, schemeData); }
tmp<multivariateSurfaceInterpolationScheme<Type> > multivariateSurfaceInterpolationScheme<Type>::New ( const fvMesh& mesh, const multivariateSurfaceInterpolationScheme<Type>::fieldTable& vtfs, const surfaceScalarField& faceFlux, Istream& schemeData ) { if (fv::debug) { Info<< "multivariateSurfaceInterpolationScheme<Type>::New" "(const fvMesh& mesh, const fieldTable&, " "const surfaceScalarField&, Istream&) : " "constructing surfaceInterpolationScheme<Type>" << endl; } word schemeName(schemeData); typename IstreamConstructorTable::iterator constructorIter = IstreamConstructorTablePtr_->find(schemeName); if (constructorIter == IstreamConstructorTablePtr_->end()) { FatalIOErrorIn ( "multivariateSurfaceInterpolationScheme<Type>::New" "(const fvMesh& mesh, const fieldTable&, " "const surfaceScalarField&, Istream&)", schemeData ) << "unknown discretisation scheme " << schemeName << endl << endl << "Valid schemes are :" << endl << IstreamConstructorTablePtr_->toc() << exit(FatalIOError); } return constructorIter()(mesh, vtfs, faceFlux, schemeData); }
void Url::setUrlType(const char* urlProtocol) { if (urlProtocol) { UtlString schemeName(urlProtocol); mScheme = scheme(schemeName); if ( UnknownUrlScheme == mScheme ) { OsSysLog::add(FAC_SIP, PRI_ERR, "Url::setUrlType unsupported Url scheme '%s'", urlProtocol ); } } else { // no urlProtocol value passed OsSysLog::add(FAC_SIP, PRI_CRIT, "Url::setUrlType Url scheme NULL"); assert(urlProtocol); mScheme = UnknownUrlScheme; } }
void UserSettingsParser::processScheme(SchemeLoaderState* pState, const XMLAttributes& atts) { LPCTSTR pName = atts.getValue(_T("name")); if(pName && ((int)_tcslen(pName) > 0)) { if(!m_loadingPreset) { CT2CA schemeName(pName); m_pCurScheme = new SchemeDetails(schemeName); } else { CT2CA schemeName(pName); SchemeDetailsMap::iterator iScheme = pState->m_SchemeDetails.find(std::string(schemeName)); if(iScheme != pState->m_SchemeDetails.end()) { m_pCurScheme = (*iScheme).second; } else { m_pCurScheme = NULL; } } if(m_pCurScheme == NULL) return; //pScheme = new CustomisedScheme; m_SchemeName = pName; pState->m_State = US_SCHEME; LPCTSTR temp = atts.getValue(_T("ovtabs")); if(temp != NULL && _tcslen(temp) > 0) { m_pCurScheme->CustomFlagFlags |= schOverrideTabs; if(SZTRUE(temp)) // Signal that we definitely want to override the tab use. m_pCurScheme->CustomFlags |= schOverrideTabs; temp = atts.getValue(_T("usetabs")); if(temp != NULL && _tcslen(temp) > 0) { m_pCurScheme->CustomFlagFlags |= schUseTabs; if(SZTRUE(temp)) m_pCurScheme->CustomFlags |= schUseTabs; } } temp = atts.getValue(_T("tabwidth")); if(temp != NULL && _tcslen(temp) > 0) { m_pCurScheme->CustomFlagFlags |= schOverrideTabSize; m_pCurScheme->CustomFlags |= schOverrideTabSize; m_pCurScheme->CustomTabWidth = _ttoi(temp); } } #ifdef _DEBUG else { LOG(_T("UserSettingsParser::processScheme(): Scheme section without name attribute.\n")); } #endif }
void Foam::fvSchemes::read(const dictionary& dict) { if (dict.found("ddtSchemes")) { ddtSchemes_ = dict.subDict("ddtSchemes"); } else if (dict.found("timeScheme")) { // For backward compatibility. // The timeScheme will be deprecated with warning or removed WarningIn("fvSchemes::read()") << "Using deprecated 'timeScheme' instead of 'ddtSchemes'" << nl << endl; word schemeName(dict.lookup("timeScheme")); if (schemeName == "EulerImplicit") { schemeName = "Euler"; } else if (schemeName == "BackwardDifferencing") { schemeName = "backward"; } else if (schemeName == "SteadyState") { schemeName = "steadyState"; } else { FatalIOErrorIn("fvSchemes::read()", dict.lookup("timeScheme")) << "\n Only EulerImplicit, BackwardDifferencing and " "SteadyState\n are supported by the old timeScheme " "specification.\n Please use ddtSchemes instead." << exit(FatalIOError); } ddtSchemes_.set("default", schemeName); ddtSchemes_.lookup("default")[0].lineNumber() = dict.lookup("timeScheme").lineNumber(); } else { ddtSchemes_.set("default", "none"); } if ( ddtSchemes_.found("default") && word(ddtSchemes_.lookup("default")) != "none" ) { defaultDdtScheme_ = ddtSchemes_.lookup("default"); } if (dict.found("d2dt2Schemes")) { d2dt2Schemes_ = dict.subDict("d2dt2Schemes"); } else if (dict.found("timeScheme")) { // For backward compatibility. // The timeScheme will be deprecated with warning or removed WarningIn("fvSchemes::read()") << "Using deprecated 'timeScheme' instead of 'd2dt2Schemes'" << nl << endl; word schemeName(dict.lookup("timeScheme")); if (schemeName == "EulerImplicit") { schemeName = "Euler"; } else if (schemeName == "SteadyState") { schemeName = "steadyState"; } d2dt2Schemes_.set("default", schemeName); d2dt2Schemes_.lookup("default")[0].lineNumber() = dict.lookup("timeScheme").lineNumber(); } else { d2dt2Schemes_.set("default", "none"); } if ( d2dt2Schemes_.found("default") && word(d2dt2Schemes_.lookup("default")) != "none" ) { defaultD2dt2Scheme_ = d2dt2Schemes_.lookup("default"); } if (dict.found("interpolationSchemes")) { interpolationSchemes_ = dict.subDict("interpolationSchemes"); } else if (!interpolationSchemes_.found("default")) { interpolationSchemes_.add("default", "linear"); } if ( interpolationSchemes_.found("default") && word(interpolationSchemes_.lookup("default")) != "none" ) { defaultInterpolationScheme_ = interpolationSchemes_.lookup("default"); } divSchemes_ = dict.subDict("divSchemes"); if ( divSchemes_.found("default") && word(divSchemes_.lookup("default")) != "none" ) { defaultDivScheme_ = divSchemes_.lookup("default"); } gradSchemes_ = dict.subDict("gradSchemes"); if ( gradSchemes_.found("default") && word(gradSchemes_.lookup("default")) != "none" ) { defaultGradScheme_ = gradSchemes_.lookup("default"); } if (dict.found("snGradSchemes")) { snGradSchemes_ = dict.subDict("snGradSchemes"); } else if (!snGradSchemes_.found("default")) { snGradSchemes_.add("default", "corrected"); } if ( snGradSchemes_.found("default") && word(snGradSchemes_.lookup("default")) != "none" ) { defaultSnGradScheme_ = snGradSchemes_.lookup("default"); } laplacianSchemes_ = dict.subDict("laplacianSchemes"); if ( laplacianSchemes_.found("default") && word(laplacianSchemes_.lookup("default")) != "none" ) { defaultLaplacianScheme_ = laplacianSchemes_.lookup("default"); } if (dict.found("fluxRequired")) { fluxRequired_ = dict.subDict("fluxRequired"); if ( fluxRequired_.found("default") && word(fluxRequired_.lookup("default")) != "none" ) { defaultFluxRequired_ = Switch(fluxRequired_.lookup("default")); } } }
void Url::getUri(UtlString& urlString) { // Insert the scheme urlString = schemeName(mScheme); urlString.append(":",1); switch(mScheme) { case FileUrlScheme: case FtpUrlScheme: case HttpUrlScheme: case HttpsUrlScheme: case RtspUrlScheme: urlString.append("//",2); break; case SipUrlScheme: case SipsUrlScheme: case MailtoUrlScheme: default: break; } // Add the user if (FileUrlScheme != mScheme) // no user defined in a file url { if(!mUserId.isNull()) { urlString.append(mUserId); if(!mPassword.isNull() || mPasswordSet) { urlString.append(":", 1); urlString.append(mPassword); } urlString.append("@", 1); } } // Add the host urlString.append(mHostAddress); if(mHostPort > 0) { char portBuffer[20]; sprintf(portBuffer, ":%d", mHostPort); urlString.append(portBuffer); } // Add the path switch(mScheme) { case FileUrlScheme: case FtpUrlScheme: case HttpUrlScheme: case HttpsUrlScheme: case RtspUrlScheme: if(!mPath.isNull()) { urlString.append(mPath); } break; case SipUrlScheme: case SipsUrlScheme: case MailtoUrlScheme: default: break; } // Add the URL parameters if ( ( mpUrlParameters || const_cast<Url*>(this)->parseUrlParameters() ) && mpUrlParameters->entries() ) { UtlDListIterator urlParamIterator(*mpUrlParameters); NameValuePair* urlParam = NULL; UtlString urlParamValue; while ((urlParam = (NameValuePair*) urlParamIterator())) { urlString.append(";", 1); urlString.append(*urlParam); urlParamValue = urlParam->getValue(); if(!urlParamValue.isNull()) { urlString.append("=", 1); HttpMessage::escape(urlParamValue); urlString.append(urlParamValue); } } } // Add the header parameters if ( ( mpHeaderOrQueryParameters || const_cast<Url*>(this)->parseHeaderOrQueryParameters() ) && mpHeaderOrQueryParameters->entries() ) { UtlDListIterator headerParamIterator(*mpHeaderOrQueryParameters); NameValuePairInsensitive* headerParam = NULL; UtlString headerParamValue; UtlBoolean firstHeader = TRUE; while ((headerParam = static_cast<NameValuePairInsensitive*>(headerParamIterator()))) { // Add separator for first header parameter if(firstHeader) { urlString.append("?", 1); firstHeader = FALSE; } else { urlString.append("&", 1); } urlString.append(*headerParam); headerParamValue = headerParam->getValue(); if(!headerParamValue.isNull()) { urlString.append("=", 1); HttpMessage::escape(headerParamValue); urlString.append(headerParamValue); } } } }