ExprType* unifyTVarR(ExprType *type, ExprType* expected, Hashtable *varTypes, Region *r) { char buf[128]; if(T_VAR_NUM_DISJUNCTS(expected)==0) { /* free */ if(occursIn(expected, type)) { return NULL; } insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), type); return dereference(expected, varTypes, r); } else { /* union type */ int i; ExprType *ty = NULL; for(i=0;i<T_VAR_NUM_DISJUNCTS(expected);i++) { if(getNodeType(type) == getNodeType(T_VAR_DISJUNCT(expected,i))) { /* union types can only include primitive types */ ty = type; } } if(ty != NULL) { insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), ty); return dereference(expected, varTypes, r); } return ty; } }
/** * Handles the contained root information. */ void HeartbeatMsgEx::processIncomingRoot() { LogContext log("Heartbeat incoming"); // check whether root info is defined if( (getNodeType() != NODETYPE_Meta) || !getRootNumID() ) return; // try to apply the contained root info if(Program::getApp()->getMetaNodes()->setRootNodeNumID(getRootNumID(), false) ) { log.log(Log_CRITICAL, "Root (by Heartbeat): " + StringTk::uintToStr(getRootNumID() ) ); Program::getApp()->getRootDir()->setOwnerNodeID(getRootNumID() ); } }
void PPFnResolveQName::do_next(xqp_tuple &t) { if (first_time) { child_qname.op->next(t); if (t.is_eos()) return; first_time = false; tuple_cell qname_tc = atomize(child_qname.get(t)); if (!is_string_type(qname_tc.get_atomic_type())) { throw XQUERY_EXCEPTION2(XPTY0004, "Wrong first argument of fn:resolve-QName function"); } child_qname.op->next(t); if (!(t.is_eos())) { throw XQUERY_EXCEPTION2(XPTY0004, "Wrong first argument of fn:resolve-QName function"); } qname_tc = tuple_cell::make_sure_light_atomic(qname_tc); child_elem.op->next(t); if (t.is_eos() || !child_elem.get(t).is_node()) { throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function"); } xptr node = child_elem.get(t).get_node(); child_elem.op->next(t); if (!(t.is_eos())) { throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function"); } CHECKP(node); if (getNodeType(node) != element) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function"); scoped_ptr<InscopeNamespaceMap> inscopeNamespaces = new InscopeNamespaceMap(node, cxt->get_static_context()->getStaticallyKnownNamespaces()); t.copy(tuple_cell::atomic(xsd::QName::createResolve(qname_tc.get_str_mem(), inscopeNamespaces.get()))); } else { first_time = true; t.set_eos(); } }
void CX3DSphereNode::print(int indent) { FILE *fp = CX3DParser::getDebugLogFp(); char *nodeName = getNodeName(); if (nodeName) { CX3DParser::printIndent(indent); fprintf(fp, "%s (%s)\n", nodeName, CX3DNode::getNodeTypeString(getNodeType())); CX3DParser::printIndent(indent+1); fprintf(fp, "solid : %s\n", getSolid()->getValue() ? "TRUE" : "FALSE"); CX3DParser::printIndent(indent+1); fprintf(fp, "radius : (%f)\n", getRadius()->getValue()); } }
void TypeCheckerVisitor::visitCallNode(CallNode* node) { uint32_t params_count = node->parametersNumber(); AstFunction* refFunc = _current_scope->lookupFunction(node->name(), true); bool matchesRefedFunction = (refFunc!= NULL) && (refFunc->parametersNumber() == params_count); for (uint32_t i = 0; i < params_count; i++) { AstNode* param = node->parameterAt(i); param->visit(this); if (matchesRefedFunction && !isAssignable(refFunc->parameterType(i), getNodeType(param))) { setErrorMessage(param, "Wrong type parameter"); } } if (matchesRefedFunction) { setNodeType(node, refFunc->returnType()); } else { setNodeType(node, VT_INVALID); } }
bool NodeBinaryOpCompare::doBinaryOperation(s32 lslot, s32 rslot, u32 slots) { assert(slots); if(m_state.isScalar(getNodeType())) //not an array { return doBinaryOperationImmediate(lslot, rslot, slots); } else { //array #ifdef SUPPORT_ARITHMETIC_ARRAY_OPS return doBinaryOperationArray(lslot, rslot, slots); #else m_state.abortNotImplementedYet(); #endif //defined below... } return false; } //end dobinaryop
void NodeBinaryOpCompare::genCode(File * fp, UVPass& uvpass) { assert(m_nodeLeft && m_nodeRight); assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //************* // generate rhs first; may update current object globals (e.g. function call) UVPass ruvpass; m_nodeRight->genCode(fp, ruvpass); // restore current object globals assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //************* UVPass luvpass; m_nodeLeft->genCode(fp, luvpass); //updates m_currentObjSymbol UTI nuti = getNodeType(); UlamType * nut = m_state.getUlamTypeByIndex(nuti); s32 tmpVarNum = m_state.getNextTmpVarNumber(); m_state.indentUlamCode(fp); fp->write("const "); fp->write(nut->getTmpStorageTypeAsString().c_str()); //e.g. u32, s32, u64.. fp->write(" "); fp->write(m_state.getTmpVarAsString(nuti, tmpVarNum, TMPREGISTER).c_str()); fp->write(" = "); fp->write(methodNameForCodeGen().c_str()); fp->write("("); UTI luti = luvpass.getPassTargetType(); //reset fp->write(luvpass.getTmpVarAsString(m_state).c_str()); fp->write(", "); fp->write(ruvpass.getTmpVarAsString(m_state).c_str()); fp->write(", "); //compare needs size of left/right nodes (only difference!) fp->write_decimal(m_state.getUlamTypeByIndex(luti)->getTotalBitSize()); fp->write(");"); GCNL; uvpass = UVPass::makePass(tmpVarNum, TMPREGISTER, nuti, m_state.determinePackable(nuti), m_state, 0, 0); //P assert(m_state.m_currentObjSymbolsForCodeGen.empty()); //************* } //genCode
void PPFnInScopePrefixes::do_next (xqp_tuple &t) { if (pos < 0) { child.op->next(t); if (t.is_eos()) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function"); if (!child.get(t).is_node()) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function"); xptr node = child.get(t).get_node(); child.op->next(t); if (!(t.is_eos())) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function"); CHECKP(node); if (getNodeType(node) != element) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function"); namespaces = new InscopeNamespaceIterator(node, cxt->get_static_context()->getStaticallyKnownNamespaces()); pos = 0; } if (namespaces->next()) { xmlns_ptr ns = namespaces->get(); if (ns->has_prefix()) t.copy(tuple_cell::atomic_deep(xs_NCName, ns->prefix)); else t.copy(EMPTY_STRING_TC); } else { t.set_eos(); pos = -1; delete namespaces; namespaces = NULL; } }
bool readDataset1D(const H5::H5File &file, const std::string &name, std::vector<_Tp> &data) { H5::DataSet dataset = file.openDataSet(name); H5::DataSpace dataspace = dataset.getSpace(); hsize_t dims_out[1]; int rank = dataspace.getSimpleExtentDims( dims_out, NULL); int _type; bool read = getNodeType(dataset, _type); read &= (_type == StorageNode::SEQ); read &= (rank == 1); if (!read) return read; data.resize(dims_out[0]); dataset.read(data.data(), dataset.getDataType()); return true; }
int typeNode( Node *node, Hashtable *varTypes, rError_t *errmsg, Node **errnode, Region *r ) { if ( ( node->option & OPTION_TYPED ) == 0 ) { /*printTree(node, 0); */ List *typingConstraints = newList( r ); Res *resType = typeExpression3( node, 0, ruleEngineConfig.extFuncDescIndex, varTypes, typingConstraints, errmsg, errnode, r ); /*printf("Type %d\n",resType->t); */ if ( getNodeType( resType ) == T_ERROR ) { addRErrorMsg( errmsg, RE_TYPE_ERROR, "type error: in rule" ); return RE_TYPE_ERROR; } postProcessCoercion( node, varTypes, errmsg, errnode, r ); postProcessActions( node, ruleEngineConfig.extFuncDescIndex, errmsg, errnode, r ); /* printTree(node, 0); */ varTypes = NULL; node->option |= OPTION_TYPED; } return 0; }
UTI NodeBlock::checkAndLabelType() { assert(m_nodeNext); //especially important for template instances (prev ptr nullified on instantiation) if(getPreviousBlockPointer() == NULL) setPreviousBlockPointer(m_state.getCurrentBlock()); else assert(getPreviousBlockPointer() == m_state.getCurrentBlock()); m_state.pushCurrentBlock(this); m_nodeNext->checkAndLabelType(); m_state.popClassContext(); //restores m_prevBlockNode setNodeType(Void); //blocks don't have types return getNodeType(); } //checkAndLabelType
bool NodeUnaryOp::doUnaryOperation(s32 slot, u32 nslots) { UTI nuti = getNodeType(); if(m_state.isScalar(nuti)) //not an array { return doUnaryOperationImmediate(slot, nslots); } else { //arrays not supported at this time std::ostringstream msg; msg << "Unsupported unary operation " << getName(); msg << ", with an array type <"; msg << m_state.getUlamTypeNameBriefByIndex(nuti).c_str() << ">"; MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), ERR); } return false; } //dobinaryop
void DeletePickedPoint::operate() { vtkIdType id_node = GuiMainWindow::pointer()->getPickedPoint(); cout << "You picked " << id_node << endl; if( id_node<0 || GuiMainWindow::pointer()->getPickedObject()!=1 ) { QApplication::restoreOverrideCursor(); EG_ERR_RETURN("Error: No node picked."); } char type; QVector <vtkIdType> PSP; //IMPORTANT: to make sure only unselected nodes become fixed (redundant with previous line, but more readable) this->m_BoundaryCodes = GuiMainWindow::pointer()->getAllBoundaryCodes(); qWarning()<<"m_BoundaryCodes="<<m_BoundaryCodes; updateNodeInfo(); QMessageBox msgBox; msgBox.setText("Delete point?"); msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No); switch (msgBox.exec()) { case QMessageBox::Yes: cout<<"yes was clicked"<<endl; DeletePoint(id_node); break; case QMessageBox::No: cout<<"no was clicked"<<endl; cout<<"=== Topological neighbours ==="<<endl; PSP = getPotentialSnapPoints(id_node); cout<<"id_node="<<id_node<<" PSP="<<PSP<<endl; cout<<"=== NODE TYPE ==="<<endl; type = getNodeType(id_node); cout<<"id_node="<<id_node<<" is of type="<<(int)type<<"="<<VertexType2Str(type)<<endl; break; default: // should never be reached break; } }
void NodeBlock::print(File * fp) { printNodeLocation(fp); UTI myut = getNodeType(); char id[255]; if((myut == Nav) || (myut == Nouti)) sprintf(id,"%s<NOTYPE>\n", prettyNodeName().c_str()); else if(myut == Hzy) sprintf(id,"%s<HAZYTYPE>\n", prettyNodeName().c_str()); else sprintf(id,"%s<%s>\n", prettyNodeName().c_str(), m_state.getUlamTypeNameByIndex(myut).c_str()); fp->write(id); if(m_nodeNext) m_nodeNext->print(fp); sprintf(id,"-----------------%s\n", prettyNodeName().c_str()); fp->write(id); } //print
SNode SNode::multiplyParentheses() const { ENTERMETHOD(); switch(getNodeType()) { case NT_NUMBER : case NT_BOOLCONST: case NT_VARIABLE : break; case NT_POWER : case NT_TREE : RETURNNODE( multiplyTreeNode() ); case NT_BOOLEXPR : RETURNNODE( multiplyBoolExpr() ); case NT_POLY : RETURNNODE( multiplyParenthesesInPoly() ); case NT_ASSIGN : RETURNNODE( multiplyAssignStmt() ); case NT_STMTLIST : RETURNNODE( multiplyStmtList() ); case NT_SUM : RETURNNODE( multiplyParenthesesInSum() ); case NT_PRODUCT : RETURNNODE( multiplyParenthesesInProduct() ); default : throwUnknownNodeTypeException(__TFUNCTION__); } RETURNTHIS; }
EvalStatus NodeConstantArray::eval() { if(!isReadyConstant()) return ERROR; UTI nuti = getNodeType(); if(!m_state.isComplete(nuti)) return ERROR; if(((SymbolConstantValue *) m_constSymbol)->getConstantStackFrameAbsoluteSlotIndex() == 0) return NOTREADY; evalNodeProlog(0); //new current node eval frame pointer, t3897 UlamValue rtnUVPtr = makeUlamValuePtr(); Node::assignReturnValueToStack(rtnUVPtr); evalNodeEpilog(); return NORMAL; } //eval
EvalStatus NodeUnaryOp::eval() { assert(m_node); UTI nuti = getNodeType(); if(nuti == Nav) return evalErrorReturn(); if(nuti == Hzy) return evalStatusReturnNoEpilog(NOTREADY); evalNodeProlog(0); //new current frame pointer u32 slots = makeRoomForNodeType(nuti); EvalStatus evs = m_node->eval(); if(evs != NORMAL) return evalStatusReturn(evs); if(!doUnaryOperation(1,slots)) return evalStatusReturn(ERROR); evalNodeEpilog(); return NORMAL; } //eval
void NodeBlockLocals::addTargetDescriptionToInfoMap(TargetMap& classtargets, u32 scid) { UTI cuti = getNodeType(); u32 classNameId = m_state.getClassNameIdForUlamLocalsFilescope(cuti); //cut->getUlamTypeNameOnly(); std::string className = m_state.m_pool.getDataAsString(classNameId); u32 mangledNameId = m_state.getMangledClassNameIdForUlamLocalsFilescope(cuti); //cut->getUlamTypeMangledName(); std::string mangledName = m_state.m_pool.getDataAsString(mangledNameId); struct TargetDesc desc; desc.m_hasTest = false; desc.m_classType = UC_LOCALSFILESCOPE; desc.m_bitsize = 0; desc.m_loc = getNodeLocation(); desc.m_className = className; desc.m_structuredComment = "NONE"; classtargets.insert(std::pair<std::string, struct TargetDesc>(mangledName, desc)); } //addTargetDescriptionToInfoMap
void CharacterData::setDataAndUpdate(const String& newData, unsigned offsetOfReplacedData, unsigned oldLength, unsigned newLength, UpdateSource source, RecalcStyleBehavior recalcStyleBehavior) { String oldData = m_data; m_data = newData; ASSERT(!layoutObject() || isTextNode()); if (isTextNode()) toText(this)->updateTextLayoutObject(offsetOfReplacedData, oldLength, recalcStyleBehavior); if (source != UpdateFromParser) { if (getNodeType() == PROCESSING_INSTRUCTION_NODE) toProcessingInstruction(this)->didAttributeChanged(); if (document().frame()) document().frame()->selection().didUpdateCharacterData(this, offsetOfReplacedData, oldLength, newLength); } document().incDOMTreeVersion(); didModifyData(oldData, source); }
void CX3DPointLightNode::print(int indent) { FILE *fp = CX3DParser::getDebugLogFp(); char *nodeName = getNodeName(); if (nodeName) { float r, g, b; float x, y, z; CX3DParser::printIndent(indent); fprintf(fp, "%s (%s)\n", nodeName, CX3DNode::getNodeTypeString(getNodeType())); CX3DParser::printIndent(indent+1); fprintf(fp, "ambientIntensity : (%f)\n", getAmbientIntensity()->getValue()); getColor()->getValue(r, g, b); CX3DParser::printIndent(indent+1); fprintf(fp, "color : (%f %f %f)\n", r, g, b); CX3DParser::printIndent(indent+1); fprintf(fp, "intensity : (%f)\n", getIntensity()->getValue()); getLocation()->getValue(x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "location : (%f %f %f)\n", x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "radius : (%f)\n", getRadius()->getValue()); getAttenuation()->getValue(x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "attenuation : (%f %f %f)\n", x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "on : %s\n", getOn()->getValue() ? "TRUE" : "FALSE"); CX3DParser::printIndent(indent+1); fprintf(fp, "global : %s\n", getGlobal()->getValue() ? "TRUE" : "FALSE"); } }
void NodeVarRef::checkAbstractInstanceErrors() { //unlike NodeVarDecl, an abstract class can be a reference! UTI nuti = getNodeType(); UlamType * nut = m_state.getUlamTypeByIndex(nuti); if(nut->getUlamTypeEnum() == Class) { SymbolClass * csym = NULL; AssertBool isDefined = m_state.alreadyDefinedSymbolClass(nuti, csym); assert(isDefined); if(csym->isAbstract()) { std::ostringstream msg; msg << "Instance of Abstract Class "; msg << m_state.getUlamTypeNameBriefByIndex(nuti).c_str(); msg << " used with reference variable symbol name '"; msg << getName() << "'"; MSG(getNodeLocationAsString().c_str(), msg.str().c_str(), INFO); } } } //checkAbstractInstanceErrors
UTI NodeBinaryOpEqualBitwise::checkAndLabelType() { UTI nodeType = NodeBinaryOp::checkAndLabelType(); //dup Bitwise calcNodeType if(nodeType != Nav) { if(!NodeBinaryOpEqual::checkStoreIntoAble()) { setNodeType(Nav); return Nav; //newType } if(!NodeBinaryOpEqual::checkNotUnpackedArray()) { setNodeType(Nav); return Nav; } } return getNodeType(); } //checkandlabeltype
/** * Class constructor: parses a given XML file and parse it with libxml2. * * @param filename XML file to parse. */ XmlReader::XmlReader(const std::string& filename) { PHYSFS_file* file = PHYSFS_openRead(filename.c_str()); if(file == 0) { std::stringstream msg; msg << "Couldn't open file '" << filename << "': " << PHYSFS_getLastError(); throw std::runtime_error(msg.str()); } reader = xmlReaderForIO(readCallback, closeCallback, file, 0, 0, XML_PARSE_NONET); if(reader == 0) { PHYSFS_close(file); std::stringstream msg; msg << "Couldn't parse file '" << filename << "'"; throw std::runtime_error(msg.str()); } while(read() && getNodeType() != XML_READER_TYPE_ELEMENT) ; }
// third arg is the slots for the rtype; slots for the left is // rslot-lslot; they should be equal, unless one is a packed array // and the other isn't; however, currently, according to // CompilerState determinePackable, they should always be the same // since their types must be identical. bool NodeBinaryOpEqualShift::doBinaryOperation(s32 lslot, s32 rslot, u32 slots) { assert(slots); UTI nuti = getNodeType(); if(m_state.isScalar(nuti)) //not an array { return doBinaryOperationImmediate(lslot, rslot, slots); } else { //array // leverage case when both are packed, for logical shift operations if(m_state.determinePackable(nuti) == PACKEDLOADABLE) { return doBinaryOperationImmediate(lslot, rslot, slots); } else { return doBinaryOperationArray(lslot, rslot, slots); } } return false; } //end dobinaryop
void TypeCheckerVisitor::visitBlockNode(BlockNode* node) { _current_scope = node->scope(); Scope::FunctionIterator funcIt(_current_scope); while (funcIt.hasNext()) { AstFunction* func = funcIt.next(); func->node()->visit(this); } int nodes_count = node->nodes(); VarType commonType = VT_VOID; for (int i = 0; i != nodes_count; ++i) { AstNode* currentNode = node->nodeAt(i); currentNode->visit(this); bool isBlockNode = currentNode->isForNode() || currentNode->isWhileNode() || currentNode->isIfNode(); VarType currentNodeType = getNodeType(currentNode); bool hasType = currentNodeType != VT_VOID; if ((isBlockNode && hasType) || (i == nodes_count - 1)) { commonType = getUpperCommonType(commonType, currentNodeType); } } setNodeType(node, commonType); _current_scope = node->scope()->parent(); }
void NodeStatements::print(File * fp) { printNodeLocation(fp); //has same location as it's node UTI myut = getNodeType(); char id[255]; if(myut == Nav) sprintf(id,"%s<NOTYPE>\n", prettyNodeName().c_str()); else sprintf(id,"%s<%s>\n", prettyNodeName().c_str(), m_state.getUlamTypeNameByIndex(myut).c_str()); fp->write(id); if(m_node) m_node->print(fp); else fp->write(" <EMPTYSTMT>\n"); if(m_nodeNext) m_nodeNext->print(fp); else fp->write(" <NONEXTSTMT>\n"); sprintf(id,"-----------------%s\n", prettyNodeName().c_str()); fp->write(id); } //print
EvalStatus NodeConstantArray::evalToStoreInto() { //possible access of constant array item (t3881) UTI nuti = getNodeType(); if(nuti == Nav) return ERROR; if(nuti == Hzy) return NOTREADY; assert(m_constSymbol); if(((SymbolConstantValue *) m_constSymbol)->getConstantStackFrameAbsoluteSlotIndex() == 0) return NOTREADY; evalNodeProlog(0); //new current node eval frame pointer UlamValue rtnUVPtr = makeUlamValuePtr(); Node::assignReturnValuePtrToStack(rtnUVPtr); evalNodeEpilog(); return NORMAL; } //evalToStoreInto
void NodeCast::genCodeCastAtomAndElement(File * fp, UlamValue & uvpass) { UTI nuti = getNodeType(); UlamType * nut = m_state.getUlamTypeByIndex(nuti); UTI vuti = uvpass.getUlamValueTypeIdx(); s32 tmpVarNum = 0; if(vuti == Ptr) { tmpVarNum = uvpass.getPtrSlotIndex(); vuti = uvpass.getPtrTargetType(); //replace } // "downcast" might not be true; compare to be sure the atom is an element "Foo" if(vuti == UAtom) { m_state.indent(fp); fp->write("if(!"); fp->write(nut->getUlamTypeMangledName().c_str()); fp->write("<EC>::THE_INSTANCE."); fp->write(m_state.getIsMangledFunctionName()); fp->write("("); fp->write(m_state.getTmpVarAsString(vuti, tmpVarNum).c_str()); fp->write("))\n"); m_state.m_currentIndentLevel++; m_state.indent(fp); fp->write("FAIL(BAD_CAST);\n"); m_state.m_currentIndentLevel--; } //update the uvpass to have the casted type uvpass = UlamValue::makePtr(tmpVarNum, uvpass.getPtrStorage(), nuti, m_state.determinePackable(nuti), m_state, 0, uvpass.getPtrNameId()); //POS 0 rightjustified; pass along name id return; } //genCodeCastAtomAndElement
void CX3DViewpointNode::print(int indent) { FILE *fp = CX3DParser::getDebugLogFp(); char *nodeName = getNodeName(); if (nodeName) { float x, y, z, rot; CX3DParser::printIndent(indent); fprintf(fp, "%s (%s)\n", nodeName, CX3DNode::getNodeTypeString(getNodeType())); CX3DParser::printIndent(indent+1); fprintf(fp, "fieldOfView : (%f)\n", getFieldOfView()->getValue()); CX3DParser::printIndent(indent+1); fprintf(fp, "jump : %s\n", getJump()->getValue() ? "TRUE" : "FALSE"); CX3DParser::printIndent(indent+1); fprintf(fp, "retainUserOffsets : %s\n", getRetainUserOffsets()->getValue() ? "TRUE" : "FALSE"); getOrientation()->getValue(x, y, z, rot); CX3DParser::printIndent(indent+1); fprintf(fp, "orientation : (%f %f %f)(%f)\n", x, y, z, rot); getPosition()->getValue(x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "position : (%f %f %f)\n", x, y, z); getCenterOfRotation()->getValue(x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "centerOfRotation : (%f %f %f)\n", x, y, z); CX3DParser::printIndent(indent+1); fprintf(fp, "description : (%s)\n", getDescription()->getValue()); } }
void FileBrowser::showContextMenu(int x, int y) { TVHITTESTINFO tvHitInfo; HTREEITEM hTreeItem; // Detect if the given position is on the element TVITEM tvHitInfo.pt.x = x; tvHitInfo.pt.y = y; tvHitInfo.flags = 0; ScreenToClient(_treeView.getHSelf(), &(tvHitInfo.pt)); hTreeItem = TreeView_HitTest(_treeView.getHSelf(), &tvHitInfo); if (tvHitInfo.hItem == nullptr) { TrackPopupMenu(_hGlobalMenu, TPM_LEFTALIGN, x, y, 0, _hSelf, NULL); } else { // Make item selected _treeView.selectItem(tvHitInfo.hItem); // get clicked item type BrowserNodeType nodeType = getNodeType(tvHitInfo.hItem); HMENU hMenu = NULL; if (nodeType == browserNodeType_root) hMenu = _hRootMenu; else if (nodeType == browserNodeType_folder) //hMenu = _hFolderMenu; return; else //nodeType_file //hMenu = _hFileMenu; return; TrackPopupMenu(hMenu, TPM_LEFTALIGN, x, y, 0, _hSelf, NULL); } }