// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString BooleanWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " SIMPL_FILTER_PARAMETER(bool, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(bool " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString DynamicTableWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " SIMPL_FILTER_PARAMETER(DynamicTableData, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(DynamicTableData " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString Symmetric6x6WidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " DREAM3D_FILTER_PARAMETER(FloatVec21_t, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(FloatVec21_t " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString OutputPathWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " DREAM3D_FILTER_PARAMETER(QString, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(QString " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString PreflightUpdatedValueWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " SIMPL_FILTER_PARAMETER(QString, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(QString " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString DataContainerReaderWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " DREAM3D_FILTER_PARAMETER(DataContainerArrayProxy, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(DataContainerArrayProxy " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString MultiDataArraySelectionWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " SIMPL_FILTER_PARAMETER(QVector<DataArrayPath>, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(QVector<DataArrayPath> " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString AttributeMatrixCreationWidgetCodeGenerator::generateFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " DREAM3D_FILTER_PARAMETER(DataArrayPath, " + getPropertyName() + ")\n";
ss << " Q_PROPERTY(DataArrayPath " + getPropertyName() + " READ get" + getPropertyName() + " WRITE set" + getPropertyName() + ")";
return contents;
}
bool GenericDataCollection::exportToCSV(CSVWriter& writer) const
{
writer.clearHeader();
for (int i=0; i<getPropertNames().size(); ++i)
{
writer.addHeader(getPropertyName(i), getPropertyTypeMeta(i));
}
writer.writeHeader();
// Export the data ordered by ID
QList<int> objKeys = m_objects.keys();
qSort(objKeys);
for (int idx=0; idx < objKeys.size(); ++idx)
{
CSVLine newLine;
GenericDataObject* obj = m_objects.value(objKeys[idx]);
for (int i=0; i<getPropertNames().size(); ++i)
{
if (obj->containsValue(getPropertyName(i)))
{
QMetaType::Type columnType = getPropertyTypeMeta(i);
bool qualified = (columnType == QMetaType::QString);
newLine.append(CSVColumn(obj->getString(getPropertyName(i)), qualified, columnType));
}
else
{
newLine.append(CSVColumn("", false, QMetaType::QString));
}
}
writer.write(newLine);
}
#if 0
QHashIterator<int, GenericDataObject*> iterator(m_objects);
while (iterator.hasNext())
{
iterator.next();
CSVLine newLine;
for (int i=0; i<getPropertNames().size(); ++i)
{
if (iterator.value()->hasValue(getPropertyName(i)))
{
QMetaType::Type columnType = CSVColumn::variantTypeToMetaType(getPropertyType(i));
bool qualified = (columnType == QMetaType::QString);
newLine.append(CSVColumn(iterator.value()->getString(getPropertyName(i)), qualified, columnType));
}
else
{
newLine.append(CSVColumn("", false, QMetaType::QString));
}
}
writer.write(newLine);
}
#endif
return true;
}
static BOOL setHead( HWND hwnd, const SUBCLASSING *pHead ) {
if( 0 != GetProp( hwnd, getPropertyName() ) ) {
RemoveProp( hwnd, getPropertyName() );
}
if ( 0 != pHead ) {
SetProp( hwnd, getPropertyName(), (HANDLE) pHead );
}
return (HANDLE) pHead == GetProp( hwnd, getPropertyName() );
}
bool DlgSetRDRPropertyByExpressionEditor::saveWidget(QSettings *settings, const QString &prefix)
{
settings->setValue(prefix+"expression", getExpression());
settings->setValue(prefix+"type", getType());
settings->setValue(prefix+"property", getPropertyName());
return true;
}
bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, double elapsedTime)
{
if (eventType == eventNames().webkitTransitionEndEvent) {
Document::ListenerType listenerType = Document::TRANSITIONEND_LISTENER;
if (shouldSendEventForListener(listenerType)) {
String propertyName = getPropertyName(m_animatingProperty);
// Dispatch the event
RefPtr<Element> element = 0;
if (m_object->node() && m_object->node()->isElementNode())
element = static_cast<Element*>(m_object->node());
ASSERT(!element || (element->document() && !element->document()->inPageCache()));
if (!element)
return false;
// Schedule event handling
m_compAnim->animationController()->addEventToDispatch(element, eventType, propertyName, elapsedTime);
// Restore the original (unanimated) style
if (eventType == eventNames().webkitTransitionEndEvent && element->renderer())
setNeedsStyleRecalc(element.get());
return true; // Did dispatch an event
}
}
return false; // Didn't dispatch an event
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString FPCodeGenerator::generateInitializationList()
{
QString contents;
QTextStream ss(&contents);
ss << " m_" + getPropertyName() + "(" + getInitValue() + "),";
return contents;
}
bool operator<( FullPN const& rhs ) const
{
if( getFullID() != rhs.getFullID() )
{
return getFullID() < rhs.getFullID();
}
return getPropertyName() < rhs.getPropertyName();
}
String PropertySetCSSStyleDeclaration::getPropertyShorthand(const String& propertyName)
{
CSSPropertyID propertyID = cssPropertyID(propertyName);
if (!propertyID)
return String();
CSSPropertyID shorthandID = m_propertySet->getPropertyShorthand(propertyID);
if (!shorthandID)
return String();
return getPropertyName(shorthandID);
}
String AbstractPropertySetCSSStyleDeclaration::item(unsigned i) const {
if (i >= propertySet().propertyCount())
return "";
StylePropertySet::PropertyReference property = propertySet().propertyAt(i);
if (property.id() == CSSPropertyVariable)
return toCSSCustomPropertyDeclaration(property.value()).name();
if (property.id() == CSSPropertyApplyAtRule)
return "@apply";
return getPropertyName(property.id());
}
String CSSStyleDeclaration::getPropertyShorthand(const String& propertyName)
{
int propID = cssPropertyID(propertyName);
if (!propID)
return String();
int shorthandID = getPropertyShorthand(propID);
if (!shorthandID)
return String();
return getPropertyName(static_cast<CSSPropertyID>(shorthandID));
}
bool operator==( FullPN const& rhs ) const
{
if( getFullID() != rhs.getFullID() )
{
return false;
}
// finally compare the ID strings
return getPropertyName() == rhs.getPropertyName();
}
String StylePropertySerializer::getPropertyText(CSSPropertyID propertyID, const String& value, bool isNotFirstDecl) const
{
StringBuilder result;
if (isNotFirstDecl)
result.append(' ');
result.append(getPropertyName(propertyID));
result.appendLiteral(": ");
result.append(value);
result.append(';');
return result.toString();
}
String CSSComputedStyleDeclaration::cssText() const
{
StringBuilder result;
const Vector<CSSPropertyID>& properties = computableProperties();
for (unsigned i = 0; i < properties.size(); i++) {
if (i)
result.append(' ');
result.append(getPropertyName(properties[i]));
result.appendLiteral(": ");
result.append(getPropertyValue(properties[i]));
result.append(';');
}
return result.toString();
}
void PropertyControlRuler::addControlItem2(ViewElement *el)
{
// double x0 = el->getLayoutX();
// double x1 = el->getWidth() + x0;
// long val = 0;
// el->event()->get<Rosegarden::Int>(getPropertyName(), val);
// double y = (double) val / MIDI_CONTROL_MAX_VALUE;
// size_t s = sizeof(MatrixElement);
// RG_DEBUG << "PropertyControlRuler::addControlItem sizeof(MatrixElement): " << s;
PropertyControlItem *controlItem = new PropertyControlItem(this, getPropertyName(), el, QPolygonF());
controlItem->update();
ControlRuler::addControlItem(controlItem);
// m_controlItemList.push_back(controlItem);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString DataContainerReaderWidgetCodeGenerator::generateSetupFilterParameters()
{
QString contents;
QTextStream ss(&contents);
ss << " {\n";
ss << " DataContainerReaderFilterParameter::Pointer parameter = DataContainerReaderFilterParameter::New();\n";
ss << " parameter->setHumanLabel(\"" + getHumanLabel() + "\");\n";
ss << " parameter->setPropertyName(\"" + getPropertyName() + "\");\n";
ss << " \n";
ss << " parameter->setDefaultFlagValue(Qt::Checked);\n";
ss << " parameter->setInputFileProperty(\"InputFilePropertyName\"); // Set this property name, if needed\n";
ss << " parameter->setCategory(" + getCategory() + ");\n";
ss << " parameters.push_back(parameter);\n";
ss << " }";
return contents;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString AttributeMatrixCreationWidgetCodeGenerator::generateReadFilterParameters()
{
return " set" + getPropertyName() + "(reader->readDataArrayPath(\"" + getPropertyName() + "\", get" + getPropertyName() + "()));";
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString AttributeMatrixCreationWidgetCodeGenerator::generateSetupFilterParameters()
{
return " parameters.push_back(AttributeMatrixCreationFilterParameter::New(\"" + getHumanLabel() + "\", \"" + getPropertyName() + "\", get" + getPropertyName() + "(), " + getCategory() + "));";
}
int main(int argc, char* argv[])
{
terrama2::core::initializeTerraMA();
{
QUrl uri;
uri.setScheme("postgis");
uri.setHost(QString::fromStdString(TERRAMA2_DATABASE_HOST));
uri.setPort(std::stoi(TERRAMA2_DATABASE_PORT));
uri.setUserName(QString::fromStdString(TERRAMA2_DATABASE_USERNAME));
uri.setPassword(QString::fromStdString(TERRAMA2_DATABASE_PASSWORD));
uri.setPath(QString::fromStdString("/"+TERRAMA2_DATABASE_DBNAME));
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = uri.url().toStdString();
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "POSTGIS";
dataProvider->active = true;
//DataSeries information
terrama2::core::DataSeries* dataSeries = new terrama2::core::DataSeries();
terrama2::core::DataSeriesPtr dataSeriesPtr(dataSeries);
auto& semanticsManager = terrama2::core::SemanticsManager::getInstance();
dataSeries->semantics = semanticsManager.getSemantics("OCCURRENCE-postgis");
//DataSet information
terrama2::core::DataSetOccurrence* dataSet = new terrama2::core::DataSetOccurrence();
dataSet->active = true;
dataSet->format.emplace("table_name", "fires");
dataSet->format.emplace("timestamp_property", "data_pas");
dataSet->format.emplace("geometry_property", "geom");
dataSeries->datasetList.emplace_back(dataSet);
//accessing data
terrama2::core::DataAccessorOccurrencePostGis accessor(dataProviderPtr, dataSeriesPtr);
//empty filter
terrama2::core::Filter filter;
boost::local_time::time_zone_ptr zone(new boost::local_time::posix_time_zone("+00"));
filter.lastValue = true;
std::string boundingBoxWkt = "POLYGON((-51.11 -17.74, -41.11 -17.74, -41.11 -20.83, -51.11 -20.83, -51.11 -17.74))";
te::gm::Geometry* geometry = te::gm::WKTReader::read(boundingBoxWkt.c_str());
geometry->setSRID(4326);
filter.region = std::shared_ptr<te::gm::Geometry>(geometry);
terrama2::core::OccurrenceSeriesPtr occurrenceSeries = accessor.getOccurrenceSeries(filter);
assert(occurrenceSeries->occurrencesMap().size() == 1);
auto teDataSet = (*occurrenceSeries->occurrencesMap().begin()).second.syncDataSet->dataset();
//Print column names and types (DateTime/Double)
int dateColumn = -1;
int geomColumn = -1;
std::string names, types;
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
std::string name = teDataSet->getPropertyName(i);
names+= name + "\t";
if(name == "data_pas")
{
types+= "DataTime\t";
dateColumn = i;
}
else if(name == "geom")
{
types+= "Geometry\t";
geomColumn = i;
}
else
types+= "Int\t";
}
std::cout << names << std::endl;
std::cout << types << std::endl;
//Print values
teDataSet->moveBeforeFirst();
while(teDataSet->moveNext())
{
for(int i = 0; i < teDataSet->getNumProperties(); ++i)
{
if(teDataSet->isNull(i))
{
std::cout << "NULL";
continue;
}
if(i == dateColumn)
{
std::shared_ptr<te::dt::DateTime> dateTime = teDataSet->getDateTime(i);
std::cout << dateTime->toString();
}
else if(i == geomColumn)
{
std::cout << "<<Geometry>>";
}
else
{
std::cout << teDataSet->getInt32(i);
}
std::cout << "\t";
}
std::cout << std::endl;
}
std::cout << "\ndataset size: " << teDataSet->size() << std::endl;
}
terrama2::core::finalizeTerraMA();
return 0;
}
String CSSProperty::cssText() const
{
return String(getPropertyName(id())) + ": " + m_value->cssText() + (isImportant() ? " !important" : "") + "; ";
}
void CompositeAnimation::updateTransitions(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
{
// If currentStyle is null or there are no old or new transitions, just skip it
if (!currentStyle || (!targetStyle->transitions() && m_transitions.isEmpty()))
return;
// Mark all existing transitions as no longer active. We will mark the still active ones
// in the next loop and then toss the ones that didn't get marked.
for (auto& transition : m_transitions.values())
transition->setActive(false);
RefPtr<RenderStyle> modifiedCurrentStyle;
// Check to see if we need to update the active transitions
if (targetStyle->transitions()) {
for (size_t i = 0; i < targetStyle->transitions()->size(); ++i) {
Animation& animation = targetStyle->transitions()->animation(i);
bool isActiveTransition = !m_suspended && (animation.duration() || animation.delay() > 0);
Animation::AnimationMode mode = animation.animationMode();
if (mode == Animation::AnimateNone)
continue;
CSSPropertyID prop = animation.property();
bool all = mode == Animation::AnimateAll;
// Handle both the 'all' and single property cases. For the single prop case, we make only one pass
// through the loop.
for (int propertyIndex = 0; propertyIndex < CSSPropertyAnimation::getNumProperties(); ++propertyIndex) {
if (all) {
// Get the next property which is not a shorthand.
bool isShorthand;
prop = CSSPropertyAnimation::getPropertyAtIndex(propertyIndex, isShorthand);
if (isShorthand)
continue;
}
// ImplicitAnimations are always hashed by actual properties, never animateAll.
ASSERT(prop >= firstCSSProperty && prop < (firstCSSProperty + numCSSProperties));
// If there is a running animation for this property, the transition is overridden
// and we have to use the unanimatedStyle from the animation. We do the test
// against the unanimated style here, but we "override" the transition later.
RefPtr<KeyframeAnimation> keyframeAnim = getAnimationForProperty(prop);
RenderStyle* fromStyle = keyframeAnim ? keyframeAnim->unanimatedStyle() : currentStyle;
// See if there is a current transition for this prop
ImplicitAnimation* implAnim = m_transitions.get(prop);
bool equal = true;
if (implAnim) {
// If we are post active don't bother setting the active flag. This will cause
// this animation to get removed at the end of this function.
if (!implAnim->postActive())
implAnim->setActive(true);
// This might be a transition that is just finishing. That would be the case
// if it were postActive. But we still need to check for equality because
// it could be just finishing AND changing to a new goal state.
//
// This implAnim might also not be an already running transition. It might be
// newly added to the list in a previous iteration. This would happen if
// you have both an explicit transition-property and 'all' in the same
// list. In this case, the latter one overrides the earlier one, so we
// behave as though this is a running animation being replaced.
if (!implAnim->isTargetPropertyEqual(prop, targetStyle)) {
// For accelerated animations we need to return a new RenderStyle with the _current_ value
// of the property, so that restarted transitions use the correct starting point.
if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
if (!modifiedCurrentStyle)
modifiedCurrentStyle = RenderStyle::clone(currentStyle);
implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get());
}
LOG(Animations, "Removing existing ImplicitAnimation %p for property %s", implAnim, getPropertyName(prop));
animationController().animationWillBeRemoved(implAnim);
m_transitions.remove(prop);
equal = false;
}
} else {
// We need to start a transition if it is active and the properties don't match
equal = !isActiveTransition || CSSPropertyAnimation::propertiesEqual(prop, fromStyle, targetStyle);
}
// We can be in this loop with an inactive transition (!isActiveTransition). We need
// to do that to check to see if we are canceling a transition. But we don't want to
// start one of the inactive transitions. So short circuit that here. (See
// <https://bugs.webkit.org/show_bug.cgi?id=24787>
if (!equal && isActiveTransition) {
// Add the new transition
RefPtr<ImplicitAnimation> implicitAnimation = ImplicitAnimation::create(animation, prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle);
LOG(Animations, "Created ImplicitAnimation %p for property %s duration %.2f delay %.2f", implicitAnimation.get(), getPropertyName(prop), animation.duration(), animation.delay());
m_transitions.set(prop, implicitAnimation.release());
}
// We only need one pass for the single prop case
if (!all)
break;
}
}
}
// Make a list of transitions to be removed
Vector<int> toBeRemoved;
for (auto& transition : m_transitions.values()) {
if (!transition->active()) {
animationController().animationWillBeRemoved(transition.get());
toBeRemoved.append(transition->animatingProperty());
LOG(Animations, "Removing ImplicitAnimation %p for property %s", transition.get(), getPropertyName(transition->animatingProperty()));
}
}
// Now remove the transitions from the list
for (auto propertyToRemove : toBeRemoved)
m_transitions.remove(propertyToRemove);
}
void CompositeAnimation::updateKeyframeAnimations(RenderElement* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
{
// Nothing to do if we don't have any animations, and didn't have any before
if (m_keyframeAnimations.isEmpty() && !targetStyle->hasAnimations())
return;
m_keyframeAnimations.checkConsistency();
if (currentStyle && currentStyle->hasAnimations() && targetStyle->hasAnimations() && *(currentStyle->animations()) == *(targetStyle->animations())) {
// The current and target animations are the same so we just need to toss any
// animation which is finished (postActive).
for (auto& animation : m_keyframeAnimations.values()) {
if (animation->postActive())
animation->setIndex(-1);
}
} else {
// Mark all existing animations as no longer active.
for (auto& animation : m_keyframeAnimations.values())
animation->setIndex(-1);
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
m_hasScrollTriggeredAnimation = false;
#endif
// Toss the animation order map.
m_keyframeAnimationOrderMap.clear();
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, none, ("none", AtomicString::ConstructFromLiteral));
// Now mark any still active animations as active and add any new animations.
if (targetStyle->animations()) {
int numAnims = targetStyle->animations()->size();
for (int i = 0; i < numAnims; ++i) {
Animation& animation = targetStyle->animations()->animation(i);
AtomicString animationName(animation.name());
if (!animation.isValidAnimation())
continue;
// See if there is a current animation for this name.
RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl());
if (keyframeAnim) {
// If this animation is postActive, skip it so it gets removed at the end of this function.
if (keyframeAnim->postActive())
continue;
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
if (animation.trigger()->isScrollAnimationTrigger())
m_hasScrollTriggeredAnimation = true;
#endif
// This one is still active.
// Animations match, but play states may differ. Update if needed.
keyframeAnim->updatePlayState(animation.playState());
// Set the saved animation to this new one, just in case the play state has changed.
keyframeAnim->setAnimation(animation);
keyframeAnim->setIndex(i);
} else if ((animation.duration() || animation.delay()) && animation.iterationCount() && animationName != none) {
keyframeAnim = KeyframeAnimation::create(animation, renderer, i, this, targetStyle);
LOG(Animations, "Creating KeyframeAnimation %p with keyframes %s, duration %.2f, delay %.2f, iterations %.2f", keyframeAnim.get(), animation.name().utf8().data(), animation.duration(), animation.delay(), animation.iterationCount());
if (m_suspended) {
keyframeAnim->updatePlayState(AnimPlayStatePaused);
LOG(Animations, " (created in suspended/paused state)");
}
#if !LOG_DISABLED
for (auto propertyID : keyframeAnim->keyframes().properties())
LOG(Animations, " property %s", getPropertyName(propertyID));
#endif
#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
if (animation.trigger()->isScrollAnimationTrigger())
m_hasScrollTriggeredAnimation = true;
#endif
m_keyframeAnimations.set(keyframeAnim->name().impl(), keyframeAnim);
}
// Add this to the animation order map.
if (keyframeAnim)
m_keyframeAnimationOrderMap.append(keyframeAnim->name().impl());
}
}
}
// Make a list of animations to be removed.
Vector<AtomicStringImpl*> animsToBeRemoved;
for (auto& animation : m_keyframeAnimations.values()) {
if (animation->index() < 0) {
animsToBeRemoved.append(animation->name().impl());
animationController().animationWillBeRemoved(animation.get());
animation->clear();
LOG(Animations, "Removing KeyframeAnimation %p", animation.get());
}
}
// Now remove the animations from the list.
for (auto nameForRemoval : animsToBeRemoved)
m_keyframeAnimations.remove(nameForRemoval);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString Symmetric6x6WidgetCodeGenerator::generateReadFilterParameters()
{
return " set" + getPropertyName() + "(reader->readFloatVec21(\"" + getPropertyName() + "\", get" + getPropertyName() + "()));";
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString Symmetric6x6WidgetCodeGenerator::generateSetupFilterParameters()
{
return " parameters.push_back(Symmetric6x6FilterParameter::New(\"" + getHumanLabel() + "\", \"" + getPropertyName() + "\", get" + getPropertyName() + "(), " + getCategory() + "));";
}
