//-----------------------------------------------------------------------------
void StamFluidSolver::vel_step ( float * u, float * v, float * u0, float * v0, float visc, float dt )
{
addSource ( u, u0, dt );
addSource ( v, v0, dt );
#if (VORTICITY_CONFINEMENT == 1)
if(mUseVorticityConfinement)
{
// add in vorticity confinement force
vorticityConfinement(u0, v0);
addSource ( u, u0, dt );
addSource ( v, v0, dt );
}
#endif
#if 0
// add in temperature force
if(mSimulateTemperature)
{
heatRise(v0);
addSource ( v, v0, dt );
}
#endif
SWAP ( u0, u );
diffuse ( 1, u, u0, visc, dt );
SWAP ( v0, v );
diffuse ( 2, v, v0, visc, dt );
project ( u, v, u0, v0 );
SWAP ( u0, u );
SWAP ( v0, v );
advect ( 1, u, u0, u0, v0, dt );
advect ( 2, v, v0, u0, v0, dt );
project ( u, v, u0, v0 );
}
bool AppsEngine::sourceRequestEvent(const QString &name)
{
if (containerForSource(name)) {
return true;
}
if (name.startsWith(QLatin1String("Apps"))) {
AppSource *appSource = new AppSource(name, this);
addSource(appSource);
return true;
} else if (name.startsWith(QLatin1String("Categories"))) {
CategoriesSource *catSource = new CategoriesSource(name, this);
addSource(catSource);
return true;
} else if (name.startsWith(QLatin1String("Groups"))) {
GroupsSource *grpsSource = new GroupsSource(name, this);
addSource(grpsSource);
return true;
} else if (name.startsWith(QLatin1String("Group"))) {
GroupSource *grpSource = new GroupSource(name, this);
addSource(grpSource);
return true;
}
return false;
}
InstSelect::InstSelect(Cfg *Func, Variable *Dest, Operand *Condition,
Operand *SourceTrue, Operand *SourceFalse)
: Inst(Func, Inst::Select, 3, Dest) {
assert(Condition->getType() == IceType_i1);
addSource(Condition);
addSource(SourceTrue);
addSource(SourceFalse);
}
void KimpanelEngine::init()
{
m_panelAgent = new PanelAgent(this);
KimpanelInputPanelContainer* inputpanelSource = new KimpanelInputPanelContainer(this, m_panelAgent);
inputpanelSource->setObjectName(INPUTPANEL_SOURCE_NAME);
KimpanelStatusBarContainer* statusbarSource = new KimpanelStatusBarContainer(this, m_panelAgent);
statusbarSource->setObjectName(STATUSBAR_SOURCE_NAME);
addSource(inputpanelSource);
addSource(statusbarSource);
this->m_panelAgent->created();
}
void FluidSolver::update() {
addSource(uv, uvOld);
if( doVorticityConfinement )
{
vorticityConfinement(uvOld);
addSource(uv, uvOld);
}
SWAP(uv, uvOld);
diffuseUV( viscocity );
project(uv, uvOld);
SWAP(uv, uvOld);
advect2d(uv, uvOld);
project(uv, uvOld);
if(doRGB)
{
addSource(color, colorOld);
SWAP(color, colorOld);
if( colorDiffusion!=0. && deltaT!=0. )
{
diffuseRGB(0, colorDiffusion );
SWAP(color, colorOld);
}
advectRGB(0, uv);
fadeRGB();
}
else
{
addSource(density, densityOld);
SWAP(density, densityOld);
if( colorDiffusion!=0. && deltaT!=0. ) {
diffuse(0, density, densityOld, colorDiffusion );
SWAP(density, densityOld);
}
advect(0, density, densityOld, uv);
fadeDensity();
}
}
void MediaStreamDescriptor::addRemoteSource(MediaStreamSource* source)
{
if (m_client)
m_client->addRemoteSource(source);
else
addSource(source);
}
bool DataContainersEngine::sourceRequestEvent(const QString &source)
{
// This engine will fetch webpages over http. First thing we do is check
// the source to make sure it is indeed an http URL.
KUrl url(source);
kDebug() << "goin to fetch" << source << url << url.protocol();
if (!url.protocol().startsWith("http", Qt::CaseInsensitive)) {
return false;
}
// Create a HttpContainer, which is a subclass of Plasma::DataContainer
HttpContainer *container = new HttpContainer(url, this);
// Set the object name to be the same as the source name; DataEngine
// relies on this to identify the container. This could also be done
// in HttpContainer's constructor, but for the sake of this example
// we're dong it here to show that it must be done *before* the
// DataContainer subclass is passed to addSource
container->setObjectName(source);
// Now we tell Plasma::DataEngine about this new container
addSource(container);
// Since we successfully set up the source, return true
return true;
}
foreach (JobView *jobView, m_pendingJobs) {
if (jobView->state() == JobView::Stopped) {
delete jobView;
} else {
addSource(jobView);
}
}
InstAlloca::InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
Variable *Dest)
: Inst(Func, Inst::Alloca, 1, Dest), AlignInBytes(AlignInBytes) {
// Verify AlignInBytes is 0 or a power of 2.
assert(AlignInBytes == 0 || llvm::isPowerOf2_32(AlignInBytes));
addSource(ByteCount);
}
void Reader::init(const int& position_in_file,const int& position_in_buffer)
{
alGenSources(1,&m_source) ;
m_stream->init(m_source,position_in_file,position_in_buffer,m_is_event) ;
addSource() ;
m_is_initialised = true ;
}
Shader& Shader::addFile(const std::string& filename) {
CORRADE_ASSERT(Utility::Directory::fileExists(filename),
"Shader file " << '\'' + filename + '\'' << " cannot be read.", *this);
addSource(Utility::Directory::readString(filename));
return *this;
}
bool UniPAX::PublicationXref::setAttribute(std::string& attribute, std::string& value, PersistenceManager& manager) {
if (UniPAX::Xref::setAttribute(attribute, value, manager))
return true;
if (boost::iequals(attribute,"url"))
{
addUrl(value);
return true;
}
if (boost::iequals(attribute,"title"))
{
setTitle(value);
return true;
}
if (boost::iequals(attribute,"source"))
{
addSource(value);
return true;
}
if (boost::iequals(attribute,"author"))
{
addAuthor(value);
return true;
}
if (boost::iequals(attribute,"year"))
{
return (PersistenceManager::convertAttribute(value,year));
}
return false;
}
GenericGraphNode::GenericGraphNode(Widget *parent, Graph *parentGraph, const std::string &title) :
GraphNode(parent, parentGraph, title)
{
Source *source = new Source(this, mParentGraph, "Output");
source->setId(fmt::format("{}GraphNodeSource", title));
addSource(source);
}
void Style::setJSON(const std::string& json, const std::string&) {
sources.clear();
layers.clear();
rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
doc.Parse<0>((const char *const)json.c_str());
if (doc.HasParseError()) {
Log::Error(Event::ParseStyle, "Error parsing style JSON at %i: %s", doc.GetErrorOffset(), rapidjson::GetParseError_En(doc.GetParseError()));
return;
}
StyleParser parser;
parser.parse(doc);
for (auto& source : parser.sources) {
addSource(std::move(source));
}
for (auto& layer : parser.layers) {
addLayer(std::move(layer));
}
glyphStore->setURL(parser.glyphURL);
spriteStore->setURL(parser.spriteURL);
loaded = true;
}
void CompositeSource::addSourceWithChapter(
const std::shared_ptr<ISeekableSource> &src,
const std::wstring &title)
{
addSource(src);
ITagParser *parser = dynamic_cast<ITagParser*>(src.get());
if (parser) {
if (count() == 1)
fetchAlbumTags(parser);
const std::vector<chapters::entry_t> *chaps;
if ((chaps = parser->getChapters())) {
std::copy(chaps->begin(), chaps->end(),
std::back_inserter(m_chapters));
return;
}
const std::map<uint32_t, std::wstring> &tags = parser->getTags();
std::map<uint32_t, std::wstring>::const_iterator
tag = tags.find(Tag::kTitle);
if (tag != tags.end()) {
addChapter(tag->second, src->length() / m_asbd.mSampleRate);
return;
}
}
addChapter(title, src->length() / m_asbd.mSampleRate);
}
void MediaStreamPrivate::addRemoteSource(MediaStreamSource* source)
{
if (m_client)
m_client->addRemoteSource(source);
else
addSource(source);
}
bool Device<MType>::initializeReporters(int machine_location,
int device_location,
ReportManagers* report_managers) {
auto neuron_manager = report_managers->getNeuronManager();
bool result = true;
result &= neuron_manager->addDescription("neuron_voltage",
DataDescription(DataSpace::Device,
DataType::Float));
result &= neuron_manager->addSource("neuron_voltage",
machine_location,
device_location,
-1,
neuron_simulator_updater_);
result &= neuron_manager->addDescription("input_current",
DataDescription(DataSpace::Device,
DataType::Float));
result &= neuron_manager->addSource("input_current",
machine_location,
device_location,
-1,
input_updater_);
result &= neuron_manager->addDescription("clamp_voltage",
DataDescription(DataSpace::Device,
DataType::Float));
result &= neuron_manager->addSource("clamp_voltage",
machine_location,
device_location,
-1,
input_updater_);
result &= neuron_manager->addDescription("clamp_voltage_bit",
DataDescription(DataSpace::Device,
DataType::Bit));
result &= neuron_manager->addSource("clamp_voltage_bit",
machine_location,
device_location,
-1,
input_updater_);
result &= neuron_manager->addDescription("synaptic_current",
DataDescription(DataSpace::Device,
DataType::Float));
result &= neuron_manager->addSource("synaptic_current",
machine_location,
device_location,
-1,
synapse_simulator_updater_);
return result;
}
bool TasksEngine::sourceRequestEvent(const QString &source)
{
if (source == "virtualDesktops") {
addSource(new VirtualDesktopsSource);
return true;
}
return false;
}
//-----------------------------------------------------------------------------
void StamFluidSolver::dens_step ( float * x, float * x0, float * u, float * v, float diff, float dt )
{
addSource ( x, x0, dt );
SWAP ( x0, x );
diffuse ( 0, x, x0, diff, dt );
SWAP ( x0, x );
advect ( 0, x, x0, u, v, dt );
}
void VFS::addNewSource(const std::string& path) {
VFSSource* source = createSource(path);
if (source) {
addSource(source);
} else {
FL_WARN(_log, LMsg("Failed to add new VFS source: ") << path);
}
}
void OGRGDALImportExtension::addWFSSource()
{
WFSSourceAddDialog AddDlg(m_TempDir,this);
if (AddDlg.exec() == QDialog::Accepted)
{
addSource(AddDlg.sourceInfos());
}
}
UIDownloaderUserManual::UIDownloaderUserManual()
{
/* Prepare instance: */
if (!m_spInstance)
m_spInstance = this;
/* Compose User Manual filename: */
QString strUserManualFullFileName = vboxGlobal().helpFile();
QString strUserManualShortFileName = QFileInfo(strUserManualFullFileName).fileName();
/* Add sources: */
addSource(QString("http://download.virtualbox.org/virtualbox/%1/").arg(vboxGlobal().vboxVersionStringNormalized()) + strUserManualShortFileName);
addSource(QString("http://download.virtualbox.org/virtualbox/") + strUserManualShortFileName);
/* Set target: */
QString strUserManualDestination = QDir(vboxGlobal().homeFolder()).absoluteFilePath(strUserManualShortFileName);
setTarget(strUserManualDestination);
}
InstFakeKill::InstFakeKill(Cfg *Func, const VarList &KilledRegs,
const Inst *Linked)
: Inst(Func, Inst::FakeKill, KilledRegs.size(), NULL), Linked(Linked) {
for (VarList::const_iterator I = KilledRegs.begin(), E = KilledRegs.end();
I != E; ++I) {
Variable *Var = *I;
addSource(Var);
}
}
void OGRGDALImportExtension::addFileSource()
{
FileSourceAddDialog AddDlg(m_InputDir,this);
if (AddDlg.exec() == QDialog::Accepted)
{
addSource(AddDlg.sourceInfos());
}
}
void Profire2626::Profire2626EAP::setupSources_mid()
{
addSource("Mic/Line/In", 0, 8, eRS_InS1, 1);
addSource("ADAT A/In", 0, 4, eRS_ADAT, 1);
addSource("ADAT B/In", 4, 4, eRS_ADAT, 1);
addSource("SPDIF/In", 14, 2, eRS_AES, 1);
addSource("Mixer/Out", 0, 16, eRS_Mixer, 1);
addSource("1394/In", 0, 16, eRS_ARX0, 1);
addSource("1394/In", 0, 10, eRS_ARX1, 17);
addSource("Mute", 0, 1, eRS_Muted);
}
void Smoke::densityStep()
{
addSource( d, dOld );
swap( dOld, d );
diffuse( 0, d, dOld, diff );
swap( dOld, d );
advect( 0, d, dOld, u, v );
}
// If TargetTrue==TargetFalse, we turn it into an unconditional
// branch. This ensures that, along with the 'switch' instruction
// semantics, there is at most one edge from one node to another.
InstBr::InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue,
CfgNode *TargetFalse)
: Inst(Func, Inst::Br, 1, NULL), TargetFalse(TargetFalse),
TargetTrue(TargetTrue) {
if (TargetTrue == TargetFalse) {
TargetTrue = NULL; // turn into unconditional version
} else {
addSource(Source);
}
}
void AudioManager::dropEvent(QDropEvent *event)
{
QList<QUrl> urls = event->mimeData()->urls();
if(urls.isEmpty())
return;
foreach(QUrl ur, urls)
{
addSource(ur.toLocalFile());
}
void EditSourcesDlg::onAddSourceButtonPressed()
{
QString dir = QFileDialog::getExistingDirectory(this,
tr("Select a folder to add to the backup"),
QDir::homePath());
if (!dir.isEmpty())
{
addSource(dir);
}
}
void QgsVirtualLayerSourceSelect::onAddSource()
{
QScopedPointer<QgsEmbeddedLayerSelectDialog> dlg( new QgsEmbeddedLayerSelectDialog( this, sMainApp ) );
int r = dlg->exec();
if ( r == QDialog::Rejected ) {
return;
}
addSource( dlg->getLocalName(), dlg->getSource(), dlg->getProvider(), dlg->getEncoding() );
}
