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);
}
}
}
}
