Tnode*
initxsource(Entry e, int dowrap)
{
Block *b;
Tnode *t, *tt;
b = dataBlock(e.score, etype(e.flags, e.depth), e.tag);
if(b == nil)
return stringnode("dataBlock: %r");
if((e.flags & VtEntryActive) == 0)
return stringnode("inactive Entry");
if(e.depth == 0) {
if(e.flags & _VtEntryDir)
tt = initxentryblock(b, copyEntry(e));
else
tt = initxdatablock(b, e.dsize);
} else {
tt = initxblock(b, smprint("%s+%d pointer", (e.flags & _VtEntryDir) ? "BtDir" : "BtData", e.depth),
ptrgen, copyEntry(e));
}
/*
* wrap the contents of the Source in a Source node,
* just so it's closer to what you see in the code.
*/
if(dowrap) {
t = stringnode("Source");
t->nkid = 1;
t->kid = mallocz(sizeof(Tnode*)*1, 1);
t->kid[0] = tt;
tt = t;
}
return tt;
}
PageItemAttributes::PageItemAttributes( QWidget* parent, const char* name, bool modal, Qt::WFlags fl )
: QDialog(parent, fl)
{
setupUi(this);
setModal(modal);
relationships << tr("None", "relationship") << tr("Relates To") << tr("Is Parent Of") << tr("Is Child Of");
relationshipsData << "none" << "relation" << "parent" << "child";
connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
connect(okButton, SIGNAL(clicked()), this, SLOT(okClicked()));
connect(attributesTable, SIGNAL(cellChanged(int,int)), this, SLOT(tableItemChanged(int,int)));
connect(addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteEntry()));
connect(clearButton, SIGNAL(clicked()), this, SLOT(clearEntries()));
connect(copyButton, SIGNAL(clicked()), this, SLOT(copyEntry()));
}
DocumentItemAttributes::DocumentItemAttributes( QWidget* parent, Qt::WFlags fl )
: QWidget(parent, fl)
{
setupUi(this);
relationships << tr("None", "relationship") << tr("Relates To") << tr("Is Parent Of") << tr("Is Child Of");
relationshipsData << "none" << "relation" << "parent" << "child";
autoAddTo << tr("None", "auto add") << tr("Text Frames") << tr("Image Frames");
autoAddToData << "none" << "textframes" << "imageframes";
types << tr("None", "types") << tr("Boolean") << tr("Integer") << tr("Real Number") << tr("String");
typesData << "none" << "boolean" << "integer" << "double" << "string";
connect(attributesTable, SIGNAL(cellChanged(int,int)), this, SLOT(tableItemChanged(int,int)));
connect(addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
connect(deleteButton, SIGNAL(clicked()), this, SLOT(deleteEntry()));
connect(clearButton, SIGNAL(clicked()), this, SLOT(clearEntries()));
connect(copyButton, SIGNAL(clicked()), this, SLOT(copyEntry()));
}
CodeGen::GenState* CodeGen::GenState::CreateEqualState(GenState * state)
{
auto result = new GenState();
result->isNew = false;
result->prev = state;
result->father_state = state->father_state;
result->upvalue_names = state->upvalue_names;
result->require_upvalues = state->require_upvalues;
result->copyEntry();
result->_var_names_size = state->_var_names_size;
result->_max_entries_size = state->_max_entries_size;
result->constant = state->constant;
result->instructions = state->instructions;
return result;
}
bool
SdfCopySpec(
const SdfLayerHandle& srcLayer, const SdfPath& srcPath,
const SdfLayerHandle& dstLayer, const SdfPath& dstPath,
const SdfShouldCopyValueFn& shouldCopyValueFn,
const SdfShouldCopyChildrenFn& shouldCopyChildrenFn)
{
if (!srcLayer || !dstLayer) {
TF_CODING_ERROR("Invalid layer handle");
return false;
}
if (srcPath.IsEmpty() || dstPath.IsEmpty()) {
TF_CODING_ERROR("Invalid empty path");
return false;
}
// Validate compatible source and destination path types.
if ((srcPath.IsAbsoluteRootOrPrimPath()
|| srcPath.IsPrimVariantSelectionPath())
!= (dstPath.IsAbsoluteRootOrPrimPath()
|| dstPath.IsPrimVariantSelectionPath())
|| srcPath.IsPropertyPath() != dstPath.IsPropertyPath()
|| srcPath.IsTargetPath() != dstPath.IsTargetPath()
|| srcPath.IsMapperPath() != dstPath.IsMapperPath()
|| srcPath.IsMapperArgPath() != dstPath.IsMapperArgPath()
|| srcPath.IsExpressionPath() != dstPath.IsExpressionPath()) {
TF_CODING_ERROR("Incompatible source and destination paths");
return false;
}
// For target paths (relationship targets and connections), verify the
// destination spec already exists. See the documentation comment.
if (dstPath.IsTargetPath() && !dstLayer->HasSpec(dstPath)) {
TF_CODING_ERROR("Spec does not exist at destination target path");
return false;
}
// This function collects all of the data that will be copied for each
// spec into this list, then applies it to the layer at the very end.
// This allows us to do some analysis on the data first.
_CopyEntryList dataToCopy;
// Create a stack of source/dest copy requests, initially populated with
// the passed parameters. The copy routine will add additional requests
// as needed to handle children etc... and runs until the stack is empty.
_CopyStack copyStack(1, _CopyStackEntry(srcPath, dstPath));
while (!copyStack.empty()) {
const _CopyStackEntry toCopy = copyStack.front();
copyStack.pop_front();
// If the source path is empty, it indicates that the spec at the
// destination path should be removed. Add an entry to the queue
// to reflect that.
if (toCopy.srcPath.IsEmpty()) {
_SpecDataEntry removeEntry(toCopy.dstPath, SdfSpecTypeUnknown);
dataToCopy.push_back(removeEntry);
continue;
}
// Figure out the concrete type of the spec we're copying. The spec type
// dictates copying behavior below.
const SdfSpecType specType = srcLayer->GetSpecType(toCopy.srcPath);
if (specType == SdfSpecTypeUnknown) {
TF_CODING_ERROR("Cannot copy unknown spec at <%s> from layer <%s>",
srcPath.GetText(), srcLayer->GetIdentifier().c_str());
return false;
}
_SpecDataEntry copyEntry(toCopy.dstPath, specType);
// Determine what data is present for the current source and dest specs
// and what needs to be copied. Divide the present fields into those
// that contain values and those that index children specs.
std::vector<TfToken> dstValueFields;
std::vector<TfToken> dstChildrenFields;
_GetFieldNames(
dstLayer, toCopy.dstPath, &dstValueFields, &dstChildrenFields);
std::vector<TfToken> srcValueFields;
std::vector<TfToken> srcChildrenFields;
_GetFieldNames(
srcLayer, toCopy.srcPath, &srcValueFields, &srcChildrenFields);
// From the list of value fields, retrieve all values that the copy
// policy says we need to copy over to the destination.
_ForEachField(
srcValueFields, dstValueFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_AddFieldValueToCopy(
specType, field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyValueFn, ©Entry.dataToCopy);
});
// Add an entry for all of the data we're copying for this spec.
dataToCopy.push_back(copyEntry);
// Now add any children specs that need to be copied to our
// copy stack.
_ForEachField(
srcChildrenFields, dstChildrenFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_ProcessChildField(
field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyChildrenFn, ©Stack);
});
}
// Now that we have all the data we want to copy, set it into the
// destination layer.
SdfChangeBlock block;
for (const _SpecDataEntry& specData : dataToCopy) {
if (specData.specType == SdfSpecTypeUnknown) {
_RemoveSpecFromLayer(dstLayer, specData);
}
else {
_AddNewSpecToLayer(dstLayer, specData);
}
for (const _FieldValuePair& fieldValue : specData.dataToCopy) {
dstLayer->SetField(
specData.dstPath, fieldValue.first, fieldValue.second);
}
}
return true;
}