void PrintSubTree(FILE *OutFile, TreeNode Node, int Indent)
{
int i,itsrank,itslocation;
itsrank = Rank(Node);
fprintf(OutFile, "[%5d] ", Node);
for (i=1; i <= Indent; i++)
fprintf(OutFile,". ");
Write_String(OutFile, NodeName(Node));
fprintf(OutFile ,"(%1d)", itsrank);
itslocation = SourceLocation(Node);
if(itslocation!=UndefinedString)
{
fprintf (OutFile, " @ ");
Write_String(OutFile, itslocation);
}
if (Decoration(Node) != 0)
fprintf(OutFile, " Decoration: %1d", Decoration(Node));
fprintf(OutFile,"\n");
for (i=1; i <= itsrank; i++)
PrintSubTree (OutFile, Child(Node, i), Indent+1);
}
UObject* UFbxFactory::ImportANode(void* VoidFbxImporter, void* VoidNode, UObject* InParent, FName InName, EObjectFlags Flags, int32& NodeIndex, int32 Total, UObject* InMesh, int LODIndex)
{
UnFbx::FFbxImporter* FFbxImporter = (UnFbx::FFbxImporter*)VoidFbxImporter;
FbxNode* Node = (FbxNode*)VoidNode;
UObject* NewObject = NULL;
FName OutputName = FFbxImporter->MakeNameForMesh(InName.ToString(), Node);
{
// skip collision models
FbxString NodeName(Node->GetName());
if ( NodeName.Find("UCX") != -1 || NodeName.Find("MCDCX") != -1 ||
NodeName.Find("UBX") != -1 || NodeName.Find("USP") != -1 )
{
return NULL;
}
NewObject = FFbxImporter->ImportStaticMesh( InParent, Node, OutputName, Flags, ImportUI->StaticMeshImportData, Cast<UStaticMesh>(InMesh), LODIndex );
}
if (NewObject)
{
NodeIndex++;
FFormatNamedArguments Args;
Args.Add( TEXT("NodeIndex"), NodeIndex );
Args.Add( TEXT("ArrayLength"), Total );
GWarn->StatusUpdate( NodeIndex, Total, FText::Format( NSLOCTEXT("UnrealEd", "Importingf", "Importing ({NodeIndex} of {ArrayLength})"), Args ) );
}
return NewObject;
}
NS_IMETHODIMP
nsXMLProcessingInstruction::GetTarget(nsAString& aTarget)
{
aTarget = NodeName();
return NS_OK;
}
void PNMLParser::transition(){
qreal x = 0, y = 0;
QString name;
QString id = xml.attributes().value("id").toString();
QString conditions, assignments;
while(xml.readNextStartElement()){
if(xml.name() == "conditions"){
conditions = xml.readElementText(QXmlStreamReader::SkipChildElements);
}else if(xml.name() == "assignments"){
assignments = xml.readElementText(QXmlStreamReader::SkipChildElements);
}else if(xml.name() == "graphics"){
position(x,y);
}else if(xml.name() == "name"){
value(name);
}else
xml.skipCurrentElement();
}
//Create transition
builder->addTransition(name.toStdString(),
conditions.toStdString(),
assignments.toStdString(),
x, y);
//Map id to name
idmap[id] = NodeName(Transition, name);
}
/**
* Exports all the animation sequences part of a single Group in a Matinee sequence
* as a single animation in the FBX document. The animation is created by sampling the
* sequence at DEFAULT_SAMPLERATE updates/second and extracting the resulting bone transforms from the given
* skeletal mesh
*/
void FFbxExporter::ExportMatineeGroup(class AMatineeActor* MatineeActor, USkeletalMeshComponent* SkeletalMeshComponent)
{
float MatineeLength = MatineeActor->MatineeData->InterpLength;
if (Scene == NULL || MatineeActor == NULL || SkeletalMeshComponent == NULL || MatineeLength == 0)
{
return;
}
FbxString NodeName("MatineeSequence");
FbxNode* BaseNode = FbxNode::Create(Scene, NodeName);
Scene->GetRootNode()->AddChild(BaseNode);
AActor* Owner = SkeletalMeshComponent->GetOwner();
if(Owner && Owner->GetRootComponent())
{
// Set the default position of the actor on the transforms
// The UE3 transformation is different from FBX's Z-up: invert the Y-axis for translations and the Y/Z angle values in rotations.
BaseNode->LclTranslation.Set(Converter.ConvertToFbxPos(Owner->GetActorLocation()));
BaseNode->LclRotation.Set(Converter.ConvertToFbxRot(Owner->GetActorRotation().Euler()));
BaseNode->LclScaling.Set(Converter.ConvertToFbxScale(Owner->GetRootComponent()->RelativeScale3D));
}
// Create the Skeleton
TArray<FbxNode*> BoneNodes;
FbxNode* SkeletonRootNode = CreateSkeleton(SkeletalMeshComponent->SkeletalMesh, BoneNodes);
FbxSkeletonRoots.Add(SkeletalMeshComponent, SkeletonRootNode);
BaseNode->AddChild(SkeletonRootNode);
ExportAnimTrack(MatineeActor, SkeletalMeshComponent);
}
/*virtual*/ string ComputationNodeBase::FormatOperationPrototype(const string& extraArgs) const
{
string prototype;
prototype += msra::strfun::strprintf("%ls = %ls", NodeName().c_str(), OperationName().c_str());
// arguments of operation
if (IsLeaf())
prototype += "()";
else
{
prototype += " (";
for (size_t i = 0; i < GetNumInputs(); i++)
{
const auto& child = m_inputs[i];
if (i > 0)
prototype += ", ";
if (child)
prototype += msra::strfun::strprintf("%ls", child->NodeName().c_str());
else
prototype += "NULL";
}
prototype += extraArgs;
prototype += ")";
}
// type (tensor dimensions) of operation
prototype += " : ";
if (!IsLeaf())
{
//prototype += "(";
for (size_t i = 0; i < GetNumInputs(); i++)
{
const auto& child = m_inputs[i];
if (i > 0)
prototype += ", ";
if (child == nullptr)
{
prototype += "NULL";
continue;
}
prototype += child->ShapeDescription().c_str();
}
prototype += extraArgs;
//prototype += ")";
}
prototype += msra::strfun::strprintf(" -> %s", ShapeDescription().c_str());
return prototype;
}
/*virtual*/ void TraceNode<ElemType>::Log(const FrameRange& fr, bool logGradientInstead) const
{
if (m_numMBsRun == 1)
{
const auto prologue = m_formattingOptions.Processed(NodeName(), m_formattingOptions.prologue, m_numMBsRun);
fprintf(stderr, "%s", prologue.c_str());
}
if (m_numMBsRun <= m_logFirst || (m_logFrequency && (m_numMBsRun-1) % m_logFrequency == 0))
{
char formatChar = !m_formattingOptions.isCategoryLabel ? 'f' : !m_formattingOptions.labelMappingFile.empty() ? 's' : 'u';
auto valueFormatString = "%" + m_formattingOptions.precisionFormat + formatChar; // format string used in fprintf() for formatting the values
const auto sequenceSeparator = m_formattingOptions.Processed(NodeName(), m_formattingOptions.sequenceSeparator, m_numMBsRun);
const auto sequencePrologue = m_formattingOptions.Processed(NodeName(), m_formattingOptions.sequencePrologue, m_numMBsRun);
const auto sequenceEpilogue = m_formattingOptions.Processed(NodeName(), m_formattingOptions.sequenceEpilogue, m_numMBsRun);
const auto elementSeparator = m_formattingOptions.Processed(NodeName(), m_formattingOptions.elementSeparator, m_numMBsRun);
const auto sampleSeparator = m_formattingOptions.Processed(NodeName(), m_formattingOptions.sampleSeparator, m_numMBsRun);
let timeRange = fr.GetTimeRange();
fprintf(stderr, "------- Trace["); // --- for better visual separability from actual content
if (fr.IsAllFrames())
;
else if (timeRange.second == timeRange.first + 1)
fprintf(stderr, "%d", (int)timeRange.first);
else if (timeRange.second > timeRange.first + 1)
fprintf(stderr, "%d..%d", (int)timeRange.first, (int)timeRange.second-1);
fprintf(stderr, "] %ls %s--> %s\n", m_message.c_str(), logGradientInstead ? "(gradient) " : "", InputRef(0).FormatOperationPrototype("").c_str());
InputRef(0).WriteMinibatchWithFormatting(stderr, fr, m_onlyUpToRow, m_onlyUpToT, m_formattingOptions.transpose, m_formattingOptions.isCategoryLabel, m_formattingOptions.isSparse, m_labelMapping,
sequenceSeparator, sequencePrologue, sequenceEpilogue, elementSeparator, sampleSeparator,
valueFormatString, logGradientInstead);
}
}
/*virtual*/ void WhereNode<ElemType>::Validate(bool isFinalValidationPass) /*override*/
{
ComputationNodeBase::Validate(isFinalValidationPass);
// we generate its own MBLayout
if (isFinalValidationPass && !Input(0)->HasMBLayout())
InvalidArgument("%ls %ls operation can only operate on minibatch data (which have a layout).", NodeName().c_str(), OperationName().c_str());
if (!m_pMBLayout)
m_pMBLayout = make_shared<MBLayout>(); // this generates a new layout
// we map scalars to scalars
if (isFinalValidationPass && Input(0)->GetSampleLayout().GetNumElements() != 1)
InvalidArgument("%ls %ls operation can only operate on scalar input.", NodeName().c_str(), OperationName().c_str());
SetDims(TensorShape(1), true);
}
void Write_Node(TreeNode Node)
{
int i;
for (i=1; i <= Rank(Node); i++)
Write_Node(Child(Node, i));
Write_String(Tree_File, NodeName(Node));
fprintf(Tree_File,"\n");
Write_String(Tree_File, SourceLocation(Node));
fprintf(Tree_File,"\n");
fprintf(Tree_File,"%1d\n", Element(Tree,Node+2));
}
void Mesh::ReadNodeHeirarchyCont(float AnimationTime,
const aiNode* pNode,
const glm::mat4& ParentTf,
unsigned int anim_index)
{
std::string NodeName(pNode->mName.data);
glm::mat4 NodeTf;
CopyaiMat(pNode->mTransformation, NodeTf);
// NOTE: the skeleton must use the same naming convention used by the .bvh files
if(_b2i_map.find(NodeName) == _b2i_map.end())
{
printf("Node: %15s\n", NodeName.c_str());
return; // bone does not exist
}
// const aiNodeAnim* pNodeAnim=FindNodeAnim(_pSceneMesh->mAnimations[anim_index],NodeName);
const aiNodeAnim* pNodeAnim = _channels[anim_index][NodeName];
if(pNodeAnim)
{
// Interpolate scaling and generate scaling transformation matrix
aiVector3D sc;
CalcInterpolatedScaling(sc, AnimationTime, pNodeAnim);
glm::mat4 ScMat=glm::scale(glm::mat4(1.0f),
glm::vec3(sc.x, sc.y, sc.z));
// printf("Node name: %s: Sc: %f %f %f\n", NodeName.c_str(), sc.x, sc.y, sc.z);
aiQuaternion quat;
CalcInterpolatedRotation(quat, AnimationTime, pNodeAnim);
glm::mat4 RotMat;
CopyaiMat(aiMatrix4x4(quat.GetMatrix()), RotMat);
aiVector3D tran;
CalcInterpolatedPosition(tran, AnimationTime, pNodeAnim);
glm::mat4 TranMat = glm::translate(glm::mat4(1.0f),
glm::vec3(tran.x, tran.y, tran.z));
NodeTf = TranMat*RotMat*ScMat;
}
glm::mat4 GlobalTf = ParentTf * NodeTf;
unsigned int BoneIdx = _b2i_map[NodeName];
_boneTfs[BoneIdx].FinalTf= _globalInvTf * GlobalTf * _boneTfs[BoneIdx].Offset;
for(unsigned int i=0; i< pNode->mNumChildren; i++)
{
ReadNodeHeirarchyCont(AnimationTime, pNode->mChildren[i], GlobalTf, anim_index);
}
}
void Loader::loadAnimation(const aiNode *pNode,int index,CMC_AnimateData * animate)
{
std::string NodeName(pNode->mName.data);
if(!m_pScene->HasAnimations ())
{
m_model->m_hasAnimation = false;
return ;
}
const aiAnimation* pAnimation = m_pScene->mAnimations[index];
const aiNodeAnim * pNodeAnim = findNodeAnim(pAnimation, NodeName);
if(pNodeAnim)//that node is a animation bone.
{
auto animateBone = new CMC_AnimateBone();
animateBone->m_boneName = NodeName;
//load position key.
for(int i =0;i<pNodeAnim->mNumPositionKeys;i++)
{
auto v = pNodeAnim->mPositionKeys[i];
CMC_TranslateKey key;
key.time = v.mTime;
key.trans = QVector3D (v.mValue.x,v.mValue.y,v.mValue.z);
animateBone->addTranslate (key);
}
//load scale key
for(int i =0;i<pNodeAnim->mNumScalingKeys;i++)
{
auto v = pNodeAnim->mScalingKeys[i];
CMC_ScaleKey key;
key.time = v.mTime;
key.scale = QVector3D (v.mValue.x,v.mValue.y,v.mValue.z);
animateBone->addScale (key);
}
//load rotation key
for(int i =0;i<pNodeAnim->mNumPositionKeys;i++)
{
auto v = pNodeAnim->mRotationKeys[i];
CMC_RotateKey key;
key.time = v.mTime;
key.rotate = QQuaternion(v.mValue.w,v.mValue.x,v.mValue.y,v.mValue.z);
animateBone->addRotate (key);
}
animate->addAnimateBone (animateBone);
animate->m_ticksPerSecond = pAnimation->mTicksPerSecond;
animate->m_duration = pAnimation->mDuration;
}
for (uint i = 0 ; i < pNode->mNumChildren ; i++) {
loadAnimation( pNode->mChildren[i],index,animate);
}
}
void Mesh::ReadNodeHeirarchyDisc(uint frame_index,
const aiNode* pNode,
const glm::mat4& ParentTf,
uint anim_index)
{
std::string NodeName(pNode->mName.data);
glm::mat4 NodeTf;
CopyaiMat(pNode->mTransformation, NodeTf);
if(_b2i_map.find(NodeName) == _b2i_map.end())
{
printf("Node: %15s\n", NodeName.c_str());
return; // bone does not exist
}
const aiNodeAnim* pNodeAnim = _channels[anim_index][NodeName];
// assume all transform types share the same amount of keys
frame_index = frame_index % pNodeAnim->mNumPositionKeys;
const aiVector3D& sc = pNodeAnim->mScalingKeys[frame_index].mValue;
const aiQuaternion& qt = pNodeAnim->mRotationKeys[frame_index].mValue;
const aiVector3D& tr = pNodeAnim->mPositionKeys[frame_index].mValue;
glm::mat4 ScMat=glm::scale(glm::mat4(1.0f),
glm::vec3(sc.x, sc.y, sc.z));
glm::mat4 RotMat;
CopyaiMat(aiMatrix4x4(qt.GetMatrix()), RotMat);
glm::mat4 TranMat = glm::translate(glm::mat4(1.0f),
glm::vec3(tr.x, tr.y, tr.z));
NodeTf = TranMat * RotMat * ScMat;
glm::mat4 GlobalTf = ParentTf * NodeTf;
unsigned int BoneIdx = _b2i_map[NodeName];
_boneTfs[BoneIdx].FinalTf= _globalInvTf * GlobalTf * _boneTfs[BoneIdx].Offset;
// For debugging: print joint position in 3D:
printf("%-15s %7.4f %7.4f %7.4f\n", pNode->mName.data,
_boneTfs[BoneIdx].FinalTf[3][0], _boneTfs[BoneIdx].FinalTf[3][1], _boneTfs[BoneIdx].FinalTf[3][2]);
// recursively update the children bones
for(unsigned int i=0; i< pNode->mNumChildren; i++)
ReadNodeHeirarchyDisc(frame_index, pNode->mChildren[i], GlobalTf, anim_index);
}
TreeNode Child(TreeNode Node, int Kid)
{
int NumberKids;
int NodeRank;
NumberKids = Rank(Node);
if(Kid < 1 || Kid > NumberKids)
{
fprintf(stderr,"***[Tree:Child] Attempted to get Child (%1d , %1d). ",Node,Kid);
fprintf(stderr,"Child Nonexistent. Node is ");
Write_String(stderr, NodeName(Node));
FatalError;
}
else
return Element (Tree, NumberKids + Node + 3 - Kid);
}
/*virtual*/ void ComputationNode<ElemType>::DumpNodeInfo(const bool /*printValues*/, const bool printMetadata, File& fstream) const
{
if (printMetadata)
{
fstream << L"\n" + NodeName() + L"=" + OperationName();
if (!IsLeaf())
{
fstream << wstring(L"(");
for (size_t i = 0; i < GetNumInputs(); i++)
{
if (i > 0)
fstream << wstring(L",");
fstream << (Input(i) ? Input(i)->NodeName() : L"NULL");
}
fstream << wstring(L")");
}
}
}
void Mesh::ReadNodeHeirarchy(float AnimationTime, const aiNode* pNode, const Matrix4f& ParentTransform)
{
string NodeName(pNode->mName.data);
const aiAnimation* pAnimation = m_pScene->mAnimations[0];
Matrix4f NodeTransformation(pNode->mTransformation);
const aiNodeAnim* pNodeAnim = FindNodeAnim(pAnimation, NodeName);
if (pNodeAnim) {
// Interpolate scaling and generate scaling transformation matrix
aiVector3D Scaling;
CalcInterpolatedScaling(Scaling, AnimationTime, pNodeAnim);
Matrix4f ScalingM;
ScalingM.InitScaleTransform(Scaling.x, Scaling.y, Scaling.z);
// Interpolate rotation and generate rotation transformation matrix
aiQuaternion RotationQ;
CalcInterpolatedRotation(RotationQ, AnimationTime, pNodeAnim);
Matrix4f RotationM = Matrix4f(RotationQ.GetMatrix());
// Interpolate translation and generate translation transformation matrix
aiVector3D Translation;
CalcInterpolatedPosition(Translation, AnimationTime, pNodeAnim);
Matrix4f TranslationM;
TranslationM.InitTranslationTransform(Translation.x, Translation.y, Translation.z);
// Combine the above transformations
NodeTransformation = TranslationM * RotationM * ScalingM;
}
Matrix4f GlobalTransformation = ParentTransform * NodeTransformation;
if (m_BoneMapping.find(NodeName) != m_BoneMapping.end()) {
uint BoneIndex = m_BoneMapping[NodeName];
m_BoneInfo[BoneIndex].FinalTransformation = m_GlobalInverseTransform * GlobalTransformation * m_BoneInfo[BoneIndex].BoneOffset;
}
for (uint i = 0 ; i < pNode->mNumChildren ; i++) {
ReadNodeHeirarchy(AnimationTime, pNode->mChildren[i], GlobalTransformation);
}
}
void ReportTreeErrorAt(TreeNode Node)
{
String Location;
fprintf(stdout, " at node ");
Write_String(stdout, NodeName(Node));
fprintf(stdout, "[%1d]", Node);
Location = SourceLocation(Node);
if(Location != UndefinedString)
{
fprintf(stdout, " @ ");
Write_String(stdout, Location);
}
fprintf(stdout, " ***\n");
IncrementErrorCount(1);
}
/*************************************************************************
* SHChangeNotifyRegister [SHELL32.2]
*
*/
ULONG WINAPI
SHChangeNotifyRegister(
HWND hwnd,
int fSources,
LONG wEventMask,
UINT uMsg,
int cItems,
SHChangeNotifyEntry *lpItems)
{
LPNOTIFICATIONLIST item;
int i;
item = (NOTIFICATIONLIST *)SHAlloc(sizeof(NOTIFICATIONLIST));
TRACE("(%p,0x%08x,0x%08x,0x%08x,%d,%p) item=%p\n",
hwnd, fSources, wEventMask, uMsg, cItems, lpItems, item);
item->next = NULL;
item->prev = NULL;
item->cidl = cItems;
item->apidl = (SHChangeNotifyEntry *)SHAlloc(sizeof(SHChangeNotifyEntry) * cItems);
for(i=0;i<cItems;i++)
{
item->apidl[i].pidl = ILClone(lpItems[i].pidl);
item->apidl[i].fRecursive = lpItems[i].fRecursive;
}
item->hwnd = hwnd;
item->uMsg = uMsg;
item->wEventMask = wEventMask;
item->wSignalledEvent = 0;
item->dwFlags = fSources;
TRACE("new node: %s\n", NodeName( item ));
EnterCriticalSection(&SHELL32_ChangenotifyCS);
AddNode(item);
LeaveCriticalSection(&SHELL32_ChangenotifyCS);
return (ULONG)item;
}
void PNMLParser::place(){
qreal x = 0, y = 0;
QString name;
QString id = xml.attributes().value("id").toString();
int initialMarking = 0;
while(xml.readNextStartElement()){
if(xml.name() == "graphics"){
position(x,y);
}else if(xml.name() == "name"){
value(name);
}else if(xml.name() == "initialMarking"){
QString val;
value(val);
initialMarking = val.toInt();
}else
xml.skipCurrentElement();
}
//Create place
builder->addPlace(name.toStdString(), initialMarking, x, y);
//Map id to name
idmap[id] = NodeName(Place, name);
}
/*virtual*/ void ScatterPackedNode<ElemType>::ForwardPropNonLooping() /*override*/
{
if (*Input(INDEXDATA)->GetMBLayout() != *Input(SOURCEDATA)->GetMBLayout())
InvalidArgument("%ls %ls operation requires the minibatch layout of index and source data to be the same.", NodeName().c_str(), OperationName().c_str());
Input(INDEXDATA)->MaskMissingValueColumnsTo(FrameRange(Input(INDEXDATA)->GetMBLayout()), -1); // indicates an invalid column to Gather/Scatter
let& index = Input(INDEXDATA)->Value(); // column indices to copy from
let& source = Input(SOURCEDATA)->Value(); // source data to copy
auto& output = Value(); // output goes here
output.DoScatterColumnsOf(/*beta=*/0, index, source, /*alpha=*/1);
}
/*virtual*/ void PackedIndexNode<ElemType>::Validate(bool isFinalValidationPass) /*override*/
{
ComputationNodeBase::Validate(isFinalValidationPass);
// inherit both MBLayout and sample dimension (scalar) from indexData
// Because we map (per-seq) index sequence to (packed) index sequence. Target is only for index calculation.
m_pMBLayout = Input(INDEXDATA)->GetMBLayout();
if (isFinalValidationPass && (!Input(INDEXDATA)->HasMBLayout() || !Input(SOURCEDATA)->HasMBLayout()))
LogicError("%ls %ls operation requires both inputs to be minibatch data (must have MBLayouts).", NodeName().c_str(), OperationName().c_str());
if (isFinalValidationPass && Input(INDEXDATA)->GetSampleLayout().GetNumElements() != 1)
InvalidArgument("%ls %ls operation requires the second argument (indexData) to be a scalar sequence.", NodeName().c_str(), OperationName().c_str());
SetDims(Input(INDEXDATA)->GetSampleLayout(), HasMBLayout());
}
/*************************************************************************
* SHChangeNotify [SHELL32.@]
*/
void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
{
LPCITEMIDLIST Pidls[2];
LPNOTIFICATIONLIST ptr;
UINT typeFlag = uFlags & SHCNF_TYPE;
Pidls[0] = NULL;
Pidls[1] = NULL;
TRACE("(0x%08x,0x%08x,%p,%p):stub.\n", wEventId, uFlags, dwItem1, dwItem2);
if( ( wEventId & SHCNE_NOITEMEVENTS ) && ( dwItem1 || dwItem2 ) )
{
TRACE("dwItem1 and dwItem2 are not zero, but should be\n");
dwItem1 = 0;
dwItem2 = 0;
return;
}
else if( ( wEventId & SHCNE_ONEITEMEVENTS ) && dwItem2 )
{
TRACE("dwItem2 is not zero, but should be\n");
dwItem2 = 0;
return;
}
if( ( ( wEventId & SHCNE_NOITEMEVENTS ) &&
( wEventId & ~SHCNE_NOITEMEVENTS ) ) ||
( ( wEventId & SHCNE_ONEITEMEVENTS ) &&
( wEventId & ~SHCNE_ONEITEMEVENTS ) ) ||
( ( wEventId & SHCNE_TWOITEMEVENTS ) &&
( wEventId & ~SHCNE_TWOITEMEVENTS ) ) )
{
WARN("mutually incompatible events listed\n");
return;
}
/* convert paths in IDLists*/
switch (typeFlag)
{
case SHCNF_PATHA:
if (dwItem1) Pidls[0] = SHSimpleIDListFromPathA((LPCSTR)dwItem1); //FIXME
if (dwItem2) Pidls[1] = SHSimpleIDListFromPathA((LPCSTR)dwItem2); //FIXME
break;
case SHCNF_PATHW:
if (dwItem1) Pidls[0] = SHSimpleIDListFromPathW((LPCWSTR)dwItem1);
if (dwItem2) Pidls[1] = SHSimpleIDListFromPathW((LPCWSTR)dwItem2);
break;
case SHCNF_IDLIST:
Pidls[0] = (LPCITEMIDLIST)dwItem1;
Pidls[1] = (LPCITEMIDLIST)dwItem2;
break;
case SHCNF_PRINTERA:
case SHCNF_PRINTERW:
FIXME("SHChangeNotify with (uFlags & SHCNF_PRINTER)\n");
return;
case SHCNF_DWORD:
default:
FIXME("unknown type %08x\n",typeFlag);
return;
}
{
WCHAR path[MAX_PATH];
if( Pidls[0] && SHGetPathFromIDListW(Pidls[0], path ))
TRACE("notify %08x on item1 = %s\n", wEventId, debugstr_w(path));
if( Pidls[1] && SHGetPathFromIDListW(Pidls[1], path ))
TRACE("notify %08x on item2 = %s\n", wEventId, debugstr_w(path));
}
EnterCriticalSection(&SHELL32_ChangenotifyCS);
/* loop through the list */
for( ptr = head; ptr; ptr = ptr->next )
{
BOOL notify;
DWORD i;
notify = FALSE;
TRACE("trying %p\n", ptr);
for( i=0; (i<ptr->cidl) && !notify ; i++ )
{
LPCITEMIDLIST pidl = ptr->apidl[i].pidl;
BOOL subtree = ptr->apidl[i].fRecursive;
if (wEventId & ptr->wEventMask)
{
if( !pidl ) /* all ? */
notify = TRUE;
else if( wEventId & SHCNE_NOITEMEVENTS )
notify = TRUE;
else if( wEventId & ( SHCNE_ONEITEMEVENTS | SHCNE_TWOITEMEVENTS ) )
notify = should_notify( Pidls[0], pidl, subtree );
else if( wEventId & SHCNE_TWOITEMEVENTS )
notify = should_notify( Pidls[1], pidl, subtree );
}
}
if( !notify )
continue;
ptr->pidlSignaled = ILClone(Pidls[0]);
TRACE("notifying %s, event %s(%x) before\n", NodeName( ptr ), DumpEvent(
wEventId ),wEventId );
ptr->wSignalledEvent |= wEventId;
if (ptr->dwFlags & SHCNRF_NewDelivery)
SendMessageW(ptr->hwnd, ptr->uMsg, (WPARAM) ptr, (LPARAM) GetCurrentProcessId());
else
SendMessageW(ptr->hwnd, ptr->uMsg, (WPARAM)Pidls, wEventId);
TRACE("notifying %s, event %s(%x) after\n", NodeName( ptr ), DumpEvent(
wEventId ),wEventId );
}
TRACE("notify Done\n");
LeaveCriticalSection(&SHELL32_ChangenotifyCS);
/* if we allocated it, free it. The ANSI flag is also set in its Unicode sibling. */
if ((typeFlag & SHCNF_PATHA) || (typeFlag & SHCNF_PRINTERA))
{
SHFree((LPITEMIDLIST)Pidls[0]);
SHFree((LPITEMIDLIST)Pidls[1]);
}
}
void ProofNode::PrintLabels(ostream& fout)
{
fout << NodeID() << " [label=" << NodeName() << "];" << endl;
if (_left) this->_left->PrintLabels(fout);
if (_right) this->_right->PrintLabels(fout);
}
/*virtual*/ void GatherPackedNode<ElemType>::Validate(bool isFinalValidationPass) /*override*/
{
ComputationNodeBase::Validate(isFinalValidationPass);
// inherit MBLayout from indexData
m_pMBLayout = Input(INDEXDATA)->GetMBLayout();
if (isFinalValidationPass && (!Input(INDEXDATA)->HasMBLayout() || !Input(SOURCEDATA)->HasMBLayout()))
LogicError("%ls %ls operation requires both inputs to be minibatch data (must have MBLayouts).", NodeName().c_str(), OperationName().c_str());
if (isFinalValidationPass && Input(INDEXDATA)->GetSampleLayout().GetNumElements() != 1)
InvalidArgument("%ls %ls operation requires the first argument (indexData) to be a scalar sequence.", NodeName().c_str(), OperationName().c_str());
// inherit tensor dimension from sourceData
SetDims(Input(SOURCEDATA)->GetSampleLayout(), HasMBLayout());
}
void LearnableParameter<ElemType>::InitFromArray(const std::vector<ElemType>& array, size_t numRows, size_t numCols)
{
// infer tensor dimensions from input file if not set
// Note: The mapping of dimensions of the input matrix to tensor dimensions are somewhat confusing.
// The file contains a 2D matrix (one row per text line) that is saved into our column-major representation.
// That representation is then reshaped into a column-major tensor.
if (GetSampleLayout().GetNumElements() == 0) // at least one dimension is 0
{
auto dims = GetSampleLayout().GetDims();
// infer rank
if (dims.size() == 0)
dims.push_back(0);
if (dims.size() == 1 && numCols != 1)
dims.push_back(0);
// infer #rows
if (dims[0] == 0) // infer row dimension as input matrix row dimension
dims[0] = numRows; // (if already set, then mismatch will be caught in VerifyDataSize() below)
// infer #cols: product of all dimensions but the first must match matrix #cols; if there is a single 0 position, we infer it
size_t zeroDim = 0; // 0 means not found
size_t prod = 1;
for (size_t k = 1; k < dims.size(); k++)
{
auto dim = dims[k];
if (dim != 0)
prod *= dim;
else if (zeroDim == 0)
zeroDim = k;
else
InvalidArgument("%ls %ls operation's specified shape [%s] cannot be inferred: Too many unknown dimensions.", NodeName().c_str(), OperationName().c_str(), string(GetSampleLayout()).c_str());
}
if (zeroDim != 0) // we found a zero
{
dims[zeroDim] = numCols / prod;
if (prod * dims[zeroDim] != numCols)
InvalidArgument("%ls %ls operation's specified shape [%s] cannot be inferred: Tensor shape cannot hold a [%d x %d] matrix.", NodeName().c_str(), OperationName().c_str(), string(GetSampleLayout()).c_str(), (int)numRows, (int)numCols);
}
SetDims(TensorShape(dims), false);
}
// BUGBUG: We should allow to read an arbitrary tensor from a single-column file.
// Currently, this would cause a matrix/tensor dimension mismatch. --TODO: Is this comment up-to-date?
Value().SetValue(numRows, numCols, m_deviceId, const_cast<ElemType*>(array.data()), matrixFlagNormal);
// TODO: Get rid of that const_cast, as soon as after Ryan's Matrix-lib refactoring separated out SetValue() from external vs. from deep copy
VerifyDataSize(Value()); // sanity check
}
/*virtual*/ void ScatterPackedNode<ElemType>::Validate(bool isFinalValidationPass) /*override*/
{
ComputationNodeBase::Validate(isFinalValidationPass);
// inherit MBLayout from layoutData (that's the only thing we use it for)
m_pMBLayout = Input(LAYOUTDATA)->GetMBLayout();
if (isFinalValidationPass && (!Input(LAYOUTDATA)->HasMBLayout() || !Input(INDEXDATA)->HasMBLayout() || !Input(SOURCEDATA)->HasMBLayout()))
LogicError("%ls %ls operation requires all inputs to be minibatch data (must have MBLayouts).", NodeName().c_str(), OperationName().c_str());
if (isFinalValidationPass && Input(INDEXDATA)->GetSampleLayout().GetNumElements() != 1)
InvalidArgument("%ls %ls operation requires the second argument (indexData) to be a scalar sequence.", NodeName().c_str(), OperationName().c_str());
// TODO: We also know that indexData and sourceData must have the same MBLayout. But that is checked at runtime.
// inherit tensor dimension from sourceData
SetDims(Input(SOURCEDATA)->GetSampleLayout(), HasMBLayout());
}
void LearnableParameter<ElemType>::ReviseFromFile(const std::wstring& reviseFromFilePath)
{
try
{
InitFromFile(reviseFromFilePath);
}
catch (const std::exception & e)
{
RuntimeError("ReviseFromFile: Failed to reload %ls %ls operation from file %ls: %s", NodeName().c_str(), OperationName().c_str(), reviseFromFilePath.c_str(), e.what());
}
}
void
DocumentType::GetName(nsAString& aName) const
{
aName = NodeName();
}
StringLeafCondition::StringLeafCondition(const char* name, const char* matchValue)
: DataNodeCondition()
{
this->name = NodeName(name);
this->matchValue = std::string(matchValue);
}
