bool RS_ActionDrawCircleTan3::getData(){ if(getStatus() != SetCircle3) return false; //find the nearest circle size_t i=0; size_t const countLines=std::count_if(circles.begin(), circles.end(), [](RS_AtomicEntity* e)->bool { return e->rtti()==RS2::EntityLine; }); for(;i<circles.size();++i) if(circles[i]->rtti() == RS2::EntityLine) break; candidates.clear(); size_t i1=(i+1)%3; size_t i2=(i+2)%3; if(i<circles.size() && circles[i]->rtti() == RS2::EntityLine){ //one or more lines LC_Quadratic lc0(circles[i],circles[i1],false); LC_Quadratic lc1; RS_VectorSolutions sol; //detect degenerate case two circles with the same radius switch(countLines){ default: case 0: //this should not happen assert(false); case 1: //1 line, two circles { for(unsigned k=0; k<4; ++k){ //loop through all mirroring cases lc1=LC_Quadratic(circles[i],circles[i1], k & 1u); LC_Quadratic lc2=LC_Quadratic(circles[i],circles[i2], k & 2u); sol.appendTo(LC_Quadratic::getIntersection(lc1,lc2)); } } break; case 2: //2 lines, one circle { if(circles[i2]->rtti()==RS2::EntityLine){ std::swap(i1, i2); } //i2 is circle for(unsigned k=0; k<4; ++k){ //loop through all mirroring cases lc1=LC_Quadratic(circles[i2],circles[i], k & 1u); LC_Quadratic lc2=LC_Quadratic(circles[i2],circles[i1], k & 2u); sol.appendTo(LC_Quadratic::getIntersection(lc1,lc2)); } } break; case 3: //3 lines { lc0=circles[i]->getQuadratic(); lc1=circles[i1]->getQuadratic(); auto lc2=circles[i2]->getQuadratic(); //attempt to have intersections (lc0, lc1), (lc0, lc2) auto sol1=LC_Quadratic::getIntersection(lc0,lc1); if(sol1.size()<1) { std::swap(lc0, lc2); std::swap(i, i2); } sol1=LC_Quadratic::getIntersection(lc0,lc2); if(sol1.size()<1) { std::swap(lc0, lc1); std::swap(i, i1); } RS_Line* line0=static_cast<RS_Line*>(circles[i]); RS_Line* line1=static_cast<RS_Line*>(circles[i1]); RS_Line* line2=static_cast<RS_Line*>(circles[i2]); lc0=line0->getQuadratic(); lc1=line1->getQuadratic(); lc2=line2->getQuadratic(); //intersection 0, 1 sol1=LC_Quadratic::getIntersection(lc0,lc1); if(!sol1.size()) { return false; } RS_Vector const v1=sol1.at(0); double angle1=0.5*(line0->getAngle1()+line1->getAngle1()); //intersection 0, 2 sol1=LC_Quadratic::getIntersection(lc0,lc2); double angle2; if(sol1.size()<1) { return false; } angle2=0.5*(line0->getAngle1()+line2->getAngle1()); RS_Vector const& v2=sol1.at(0); //two bisector lines per intersection for(unsigned j=0; j<2; ++j){ RS_Line l1(nullptr, RS_LineData(v1, v1+RS_Vector(angle1))); for(unsigned j1=0; j1<2; ++j1){ RS_Line l2(nullptr, RS_LineData(v2, v2+RS_Vector(angle2))); sol.appendTo(RS_Information::getIntersectionLineLine(&l1, &l2)); angle2 += M_PI_2; } angle1 += M_PI_2; } } } double d; //line passes circle center, need a second parabola as the image of the line for(int j=1;j<=2;j++){ if(circles[(i+j)%3]->rtti() == RS2::EntityCircle){ circles[i]->getNearestPointOnEntity(circles[(i+j)%3]->getCenter(), false,&d); if(d<RS_TOLERANCE) { LC_Quadratic lc2(circles[i],circles[(i+j)%3], true); sol.appendTo(LC_Quadratic::getIntersection(lc2,lc1)); } } } //clean up duplicate and invalid RS_VectorSolutions sol1; for(const RS_Vector& vp: sol){ if(vp.magnitude()>RS_MAXDOUBLE) continue; if(sol1.size() && sol1.getClosestDistance(vp)<RS_TOLERANCE) continue; sol1.push_back(vp); } for(auto const& v: sol1){ circles[i]->getNearestPointOnEntity(v,false,&d); std::shared_ptr<RS_CircleData> data(new RS_CircleData(v,d)); if(circles[(i+1)%3]->isTangent(*data)==false) continue; if(circles[(i+2)%3]->isTangent(*data)==false) continue; candidates.push_back(data); } }else{ RS_Circle c(nullptr,*cData); auto solutions=c.createTan3(circles); candidates.clear(); for(const RS_Circle& s: solutions){ candidates.push_back(std::make_shared<RS_CircleData>(s.getData())); } } valid = ( candidates.size() >0); return valid; }
void KontextListList::setcur_hist(int i, int n) { iKontextListList l = at(i); (*l)->setcur(n); }
inline reference operator[](size_type pos) { return at(pos); }
bool ObstructionMap::isConsidered(Position position) { return at(position) == OT_CONSIDERED; }
void KontextList::setcur(int n) { (*_cont)->setOpenflag(false); _cont = at(n); }
void vl_dsift_process (VlDsiftFilter* self, float const* im) { int t, x, y ; /* update buffers */ _vl_dsift_alloc_buffers (self) ; /* clear integral images */ for (t = 0 ; t < self->geom.numBinT ; ++t) memset (self->grads[t], 0, sizeof(float) * self->imWidth * self->imHeight) ; #undef at #define at(x,y) (im[(y)*self->imWidth+(x)]) /* Compute gradients, their norm, and their angle */ for (y = 0 ; y < self->imHeight ; ++ y) { for (x = 0 ; x < self->imWidth ; ++ x) { float gx, gy ; float angle, mod, nt, rbint ; int bint ; /* y derivative */ if (y == 0) { gy = at(x,y+1) - at(x,y) ; } else if (y == self->imHeight - 1) { gy = at(x,y) - at(x,y-1) ; } else { gy = 0.5F * (at(x,y+1) - at(x,y-1)) ; } /* x derivative */ if (x == 0) { gx = at(x+1,y) - at(x,y) ; } else if (x == self->imWidth - 1) { gx = at(x,y) - at(x-1,y) ; } else { gx = 0.5F * (at(x+1,y) - at(x-1,y)) ; } /* angle and modulus */ angle = vl_fast_atan2_f (gy,gx) ; mod = vl_fast_sqrt_f (gx*gx + gy*gy) ; /* quantize angle */ nt = vl_mod_2pi_f (angle) * (self->geom.numBinT / (2*VL_PI)) ; bint = vl_floor_f (nt) ; rbint = nt - bint ; /* write it back */ self->grads [(bint ) % self->geom.numBinT][x + y * self->imWidth] = (1 - rbint) * mod ; self->grads [(bint + 1) % self->geom.numBinT][x + y * self->imWidth] = ( rbint) * mod ; } } if (self->useFlatWindow) { _vl_dsift_with_flat_window(self) ; } else { _vl_dsift_with_gaussian_window(self) ; } { VlDsiftKeypoint* frameIter = self->frames ; float * descrIter = self->descrs ; int framex, framey, bint ; int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ; int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ; int descrSize = vl_dsift_get_descriptor_size (self) ; float deltaCenterX = 0.5F * self->geom.binSizeX * (self->geom.numBinX - 1) ; float deltaCenterY = 0.5F * self->geom.binSizeY * (self->geom.numBinY - 1) ; float normConstant = frameSizeX * frameSizeY ; if (self->useFlatWindow) { /* invoncoltri is normalized */ normConstant /= self->geom.binSizeX * self->geom.binSizeY ; } for (framey = self->boundMinY ; framey <= self->boundMaxY - frameSizeY + 1 ; framey += self->stepY) { for (framex = self->boundMinX ; framex <= self->boundMaxX - frameSizeX + 1 ; framex += self->stepX) { frameIter->x = framex + deltaCenterX ; frameIter->y = framey + deltaCenterY ; /* mass */ { float mass = 0 ; for (bint = 0 ; bint < descrSize ; ++ bint) mass += descrIter[bint] ; mass /= normConstant ; frameIter->norm = mass ; } /* L2 normalize */ _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ; /* clamp */ for(bint = 0 ; bint < descrSize ; ++ bint) if (descrIter[bint] > 0.2F) descrIter[bint] = 0.2F ; /* L2 normalize */ _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ; frameIter ++ ; descrIter += descrSize ; } /* for framex */ } /* for framey */ } }
bool Address::isMulticast() const { return (at(0) & 1) != 0; }
bool Board::isGate(int pos) { if (inBounds(pos)) return ((at(pos) & fixBits) == gate ? TRUE : FALSE); return FALSE; }
bool Board::isTunnel(int pos) { if (inBounds(pos)) return ((at(pos) & fixBits) == tunnel ? TRUE : FALSE); return FALSE; }
bool Board::isBrick(int pos) { if (inBounds(pos)) return ((at(pos) & fixBits) == brick ? TRUE : FALSE); return FALSE; }
bool Board::isPrison(int pos) { if (inBounds(pos)) return ((at(pos) & fixBits) == prison ? TRUE : FALSE); return FALSE; }
bool Board::isEmpty(int pos) { if (inBounds(pos)) return ((at(pos) & fixBits) == empty ? TRUE : FALSE); return TRUE; }
bool Board::isOut(int pos) { if (inBounds(pos)) return (at(pos) == OUT ? TRUE : FALSE); return TRUE; }
void Board::set(int pos, Square sq, int m) { if (inBounds(pos)) switch (sq) { case out : at(pos) = OUT; break; case Point : at(pos) |= pointBit; numPoints++; break; case tunnel : at(pos) = sq; for (int e = 0; e < numTunnels; e++) { // if tunnel is already on board if (tunnelPosition[e] == pos) // don't do it again. pos = OUT; } if (pos != OUT) { tunnelPosition[numTunnels] = pos; numTunnels++; } break; case energizer : at(pos) |= energizerBit; for (int e = 0; e < numEnergizers; e++) { if (energizerPosition[e] == pos) pos = OUT; } if (pos != OUT) { energizerPosition[numEnergizers] = pos; numEnergizers++; } break; case fruit : at(pos) |= fruitBit; fruitPosition = pos; break; case pacman : at(pos) |= pacmanBit; pacmanPosition = pos; break; case monster : at(pos) |= (monsterBit << m); monsterPosition[m] = pos; break; case prisonentry : prisonEntry = pos; at(pos) = empty; break; case prisonexit : prisonExit = pos; at(pos) = empty; break; case fruithome : fruitHome = pos; at(pos) = empty; break; case pacmanhome : pacmanHome = pos; at(pos) = empty; break; case monsterhome : monsterHome[m] = pos; at(pos) = empty; if (m == 0 && prisonExit == OUT) prisonExit = pos; if (m == 1 && prisonEntry == OUT) prisonEntry = pos; numMonsters++; break; default : at(pos) = sq; } }
// returns true if a block tag was closed bool QTextHtmlImporter::closeTag() { const QTextHtmlParserNode *closedNode = &at(currentNodeIdx - 1); const int endDepth = depth(currentNodeIdx) - 1; int depth = this->depth(currentNodeIdx - 1); bool blockTagClosed = false; while (depth > endDepth) { Table *t = 0; if (!tables.isEmpty()) t = &tables.last(); switch (closedNode->id) { case Html_tr: if (t && !t->isTextFrame) { ++t->currentRow; // for broken html with rowspans but missing tr tags while (!t->currentCell.atEnd() && t->currentCell.row < t->currentRow) ++t->currentCell; } blockTagClosed = true; break; case Html_table: if (!t) break; indent = t->lastIndent; tables.resize(tables.size() - 1); t = 0; if (tables.isEmpty()) { cursor = doc->rootFrame()->lastCursorPosition(); } else { t = &tables.last(); if (t->isTextFrame) cursor = t->frame->lastCursorPosition(); else if (!t->currentCell.atEnd()) cursor = t->currentCell.cell().lastCursorPosition(); } // we don't need an extra block after tables, so we don't // claim to have closed one for the creation of a new one // in import() blockTagClosed = false; compressNextWhitespace = RemoveWhiteSpace; break; case Html_th: case Html_td: if (t && !t->isTextFrame) ++t->currentCell; blockTagClosed = true; compressNextWhitespace = RemoveWhiteSpace; break; case Html_ol: case Html_ul: if (lists.isEmpty()) break; lists.resize(lists.size() - 1); --indent; blockTagClosed = true; break; case Html_br: compressNextWhitespace = RemoveWhiteSpace; break; case Html_div: if (closedNode->children.isEmpty()) break; // fall through default: if (closedNode->isBlock()) blockTagClosed = true; break; } closedNode = &at(closedNode->parent); --depth; } return blockTagClosed; }
bool Board::isEnergizer(int pos) { if (inBounds(pos) && at(pos) != OUT) return ((at(pos) & energizerBit) != 0 ? TRUE : FALSE); return FALSE; }
QTextHtmlImporter::Table QTextHtmlImporter::scanTable(int tableNodeIdx) { Table table; table.columns = 0; QVector<QTextLength> columnWidths; int tableHeaderRowCount = 0; QVector<int> rowNodes; rowNodes.reserve(at(tableNodeIdx).children.count()); foreach (int row, at(tableNodeIdx).children) switch (at(row).id) { case Html_tr: rowNodes += row; break; case Html_thead: case Html_tbody: case Html_tfoot: foreach (int potentialRow, at(row).children) if (at(potentialRow).id == Html_tr) { rowNodes += potentialRow; if (at(row).id == Html_thead) ++tableHeaderRowCount; } break; default: break; } QVector<RowColSpanInfo> rowColSpans; QVector<RowColSpanInfo> rowColSpanForColumn; int effectiveRow = 0; foreach (int row, rowNodes) { int colsInRow = 0; foreach (int cell, at(row).children) if (at(cell).isTableCell()) { // skip all columns with spans from previous rows while (colsInRow < rowColSpanForColumn.size()) { const RowColSpanInfo &spanInfo = rowColSpanForColumn[colsInRow]; if (spanInfo.row + spanInfo.rowSpan > effectiveRow) { Q_ASSERT(spanInfo.col == colsInRow); colsInRow += spanInfo.colSpan; } else break; } const QTextHtmlParserNode &c = at(cell); const int currentColumn = colsInRow; colsInRow += c.tableCellColSpan; RowColSpanInfo spanInfo; spanInfo.row = effectiveRow; spanInfo.col = currentColumn; spanInfo.colSpan = c.tableCellColSpan; spanInfo.rowSpan = c.tableCellRowSpan; if (spanInfo.colSpan > 1 || spanInfo.rowSpan > 1) rowColSpans.append(spanInfo); columnWidths.resize(qMax(columnWidths.count(), colsInRow)); rowColSpanForColumn.resize(columnWidths.size()); for (int i = currentColumn; i < currentColumn + c.tableCellColSpan; ++i) { if (columnWidths.at(i).type() == QTextLength::VariableLength) { QTextLength w = c.width; if (c.tableCellColSpan > 1 && w.type() != QTextLength::VariableLength) w = QTextLength(w.type(), w.value(100.) / c.tableCellColSpan); columnWidths[i] = w; } rowColSpanForColumn[i] = spanInfo; } } table.columns = qMax(table.columns, colsInRow); ++effectiveRow; }
bool Board::isFruit(int pos) { if (inBounds(pos) && at(pos) != OUT) return ((at(pos) & fruitBit) != 0 ? TRUE : FALSE); return FALSE; }
BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable) { LLFastTimer ftm(FTM_UPDATE_PARTICLES); dirtySpatialGroup(); S32 num_parts = mViewerPartGroupp->getCount(); LLFace *facep; LLSpatialGroup* group = drawable->getSpatialGroup(); if (!group && num_parts) { drawable->movePartition(); group = drawable->getSpatialGroup(); } if (group && group->isVisible()) { dirtySpatialGroup(TRUE); } if (!num_parts) { if (group && drawable->getNumFaces()) { group->setState(LLSpatialGroup::GEOM_DIRTY); } drawable->setNumFaces(0, NULL, getTEImage(0)); LLPipeline::sCompiles++; return TRUE; } if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES))) { return TRUE; } if (num_parts > drawable->getNumFaces()) { drawable->setNumFacesFast(num_parts+num_parts/4, NULL, getTEImage(0)); } F32 tot_area = 0; F32 max_area = LLViewerPartSim::getMaxPartCount() * MAX_PARTICLE_AREA_SCALE; F32 pixel_meter_ratio = LLViewerCamera::getInstance()->getPixelMeterRatio(); pixel_meter_ratio *= pixel_meter_ratio; LLViewerPartSim::checkParticleCount(mViewerPartGroupp->mParticles.size()) ; S32 count=0; mDepth = 0.f; S32 i = 0 ; LLVector3 camera_agent = getCameraPosition(); for (i = 0 ; i < (S32)mViewerPartGroupp->mParticles.size(); i++) { const LLViewerPart *part = mViewerPartGroupp->mParticles[i]; LLVector3 part_pos_agent(part->mPosAgent); LLVector3 at(part_pos_agent - camera_agent); F32 camera_dist_squared = at.lengthSquared(); F32 inv_camera_dist_squared; if (camera_dist_squared > 1.f) inv_camera_dist_squared = 1.f / camera_dist_squared; else inv_camera_dist_squared = 1.f; F32 area = part->mScale.mV[0] * part->mScale.mV[1] * inv_camera_dist_squared; tot_area = llmax(tot_area, area); if (tot_area > max_area) { break; } count++; facep = drawable->getFace(i); if (!facep) { llwarns << "No face found for index " << i << "!" << llendl; continue; } facep->setTEOffset(i); const F32 NEAR_PART_DIST_SQ = 5.f*5.f; // Only discard particles > 5 m from the camera const F32 MIN_PART_AREA = .005f*.005f; // only less than 5 mm x 5 mm at 1 m from camera if (camera_dist_squared > NEAR_PART_DIST_SQ && area < MIN_PART_AREA) { facep->setSize(0, 0); continue; } facep->setSize(4, 6); facep->setViewerObject(this); if (part->mFlags & LLPartData::LL_PART_EMISSIVE_MASK) { facep->setState(LLFace::FULLBRIGHT); } else { facep->clearState(LLFace::FULLBRIGHT); } facep->mCenterLocal = part->mPosAgent; facep->setFaceColor(part->mColor); facep->setTexture(part->mImagep); //check if this particle texture is replaced by a parcel media texture. if(part->mImagep.notNull() && part->mImagep->hasParcelMedia()) { part->mImagep->getParcelMedia()->addMediaToFace(facep) ; } mPixelArea = tot_area * pixel_meter_ratio; const F32 area_scale = 10.f; // scale area to increase priority a bit facep->setVirtualSize(mPixelArea*area_scale); } for (i = count; i < drawable->getNumFaces(); i++) { LLFace* facep = drawable->getFace(i); if (!facep) { llwarns << "No face found for index " << i << "!" << llendl; continue; } facep->setTEOffset(i); facep->setSize(0, 0); } mDrawable->movePartition(); LLPipeline::sCompiles++; return TRUE; }
bool Board::isPacman(int pos) { if (inBounds(pos) && at(pos) != OUT) return ((at(pos) & pacmanBit) != 0 ? TRUE : FALSE); return FALSE; }
bool ObstructionMap::isObstructed(Position position) { return at(position) == OT_OBSTRUCTED; }
bool Board::isMonster(int pos) { if (inBounds(pos) && at(pos) != OUT) return ((at(pos) & monsterBits) != 0 ? TRUE : FALSE); return FALSE; }
bool ObstructionMap::isOpen(Position position) { return at(position) == OT_EMPTY; }
std::vector<ArtifactName> ArtifactData::getArtifactsInProvince(ProvinceName province) { auto artifacts = ProvinceArtifacts.at(province); assert(artifacts.size() > 0); return artifacts; }
void KontextListList::setcur(int n, int k) { (***cc)->setOpenflag(false); cc = at(n); (*cc)->setcur(k); }
void QTextHtmlImporter::import() { cursor.beginEditBlock(); hasBlock = true; forceBlockMerging = false; compressNextWhitespace = RemoveWhiteSpace; blockTagClosed = false; for (currentNodeIdx = 0; currentNodeIdx < count(); ++currentNodeIdx) { currentNode = &at(currentNodeIdx); wsm = textEditMode ? QTextHtmlParserNode::WhiteSpacePreWrap : currentNode->wsm; /* * process each node in three stages: * 1) check if the hierarchy changed and we therefore passed the * equivalent of a closing tag -> we may need to finish off * some structures like tables * * 2) check if the current node is a special node like a * <table>, <ul> or <img> tag that requires special processing * * 3) if the node should result in a QTextBlock create one and * finally insert text that may be attached to the node */ /* emit 'closing' table blocks or adjust current indent level * if we * 1) are beyond the first node * 2) the current node not being a child of the previous node * means there was a tag closing in the input html */ if (currentNodeIdx > 0 && (currentNode->parent != currentNodeIdx - 1)) { blockTagClosed = closeTag(); // visually collapse subsequent block tags, but if the element after the closed block tag // is for example an inline element (!isBlock) we have to make sure we start a new paragraph by setting // hasBlock to false. if (blockTagClosed && !currentNode->isBlock() && currentNode->id != Html_unknown) { hasBlock = false; } else if (hasBlock) { // when collapsing subsequent block tags we need to clear the block format QTextBlockFormat blockFormat = currentNode->blockFormat; blockFormat.setIndent(indent); QTextBlockFormat oldFormat = cursor.blockFormat(); if (oldFormat.hasProperty(QTextFormat::PageBreakPolicy)) { QTextFormat::PageBreakFlags pageBreak = oldFormat.pageBreakPolicy(); if (pageBreak == QTextFormat::PageBreak_AlwaysAfter) /* We remove an empty paragrah that requested a page break after. moving that request to the next paragraph means we also need to make that a pagebreak before to keep the same visual appearance. */ pageBreak = QTextFormat::PageBreak_AlwaysBefore; blockFormat.setPageBreakPolicy(pageBreak); } cursor.setBlockFormat(blockFormat); } } if (currentNode->displayMode == QTextHtmlElement::DisplayNone) { if (currentNode->id == Html_title) doc->setMetaInformation(QTextDocument::DocumentTitle, currentNode->text); // ignore explicitly 'invisible' elements continue; } if (processSpecialNodes() == ContinueWithNextNode) continue; // make sure there's a block for 'Blah' after <ul><li>foo</ul>Blah if (blockTagClosed && !hasBlock && !currentNode->isBlock() && !currentNode->text.isEmpty() && !currentNode->hasOnlyWhitespace() && currentNode->displayMode == QTextHtmlElement::DisplayInline) { QTextBlockFormat block = currentNode->blockFormat; block.setIndent(indent); appendBlock(block, currentNode->charFormat); hasBlock = true; } if (currentNode->isBlock()) { if (processBlockNode() == ContinueWithNextNode) continue; } if (currentNode->charFormat.isAnchor() && !currentNode->charFormat.anchorName().isEmpty()) { namedAnchors.append(currentNode->charFormat.anchorName()); } if (appendNodeText()) hasBlock = false; // if we actually appended text then we don't // have an empty block anymore } cursor.endEditBlock(); }
// Checked: 2009-06-18 (RLVa-0.2.1d) | Modified: RLVa-0.2.1d BOOL RlvExtGetSet::processCommand(const LLUUID& idObj, const RlvCommand& rlvCmd) { std::string strBehaviour = rlvCmd.getBehaviour(), strGetSet, strSetting; int idxSetting = strBehaviour.find('_'); if ( (strBehaviour.length() >= 6) && (-1 != idxSetting) && ((int)strBehaviour.length() > idxSetting + 1) ) { strSetting = strBehaviour.substr(idxSetting + 1); strBehaviour.erase(idxSetting); // Get rid of "_<setting>" strGetSet = strBehaviour.substr(0, 3); strBehaviour.erase(0, 3); // Get rid of get/set if ("debug" == strBehaviour) { if ( ("get" == strGetSet) && (RLV_TYPE_REPLY == rlvCmd.getParamType()) ) { rlvSendChatReply(rlvCmd.getParam(), onGetDebug(strSetting)); return TRUE; } else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) ) { if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETDEBUG, idObj)) onSetDebug(strSetting, rlvCmd.getOption()); return TRUE; } } else if ("env" == strBehaviour) { if ( ("get" == strGetSet) && (RLV_TYPE_REPLY == rlvCmd.getParamType()) ) { rlvSendChatReply(rlvCmd.getParam(), onGetEnv(strSetting)); return TRUE; } else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) ) { if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETENV, idObj)) onSetEnv(strSetting, rlvCmd.getOption()); return TRUE; } } } else if ("setrot" == rlvCmd.getBehaviour()) { // NOTE: if <option> is invalid (or missing) altogether then RLV-1.17 will rotate to 0.0 (which is actually PI / 4) F32 nAngle = 0.0f; if (LLStringUtil::convertToF32(rlvCmd.getOption(), nAngle)) { nAngle += RLV_SETROT_OFFSET; gAgent.startCameraAnimation(); LLVector3 at(LLVector3::x_axis); at.rotVec(nAngle, LLVector3::z_axis); at.normalize(); gAgent.resetAxes(at); return TRUE; } } return FALSE; }
QTextHtmlImporter::ProcessNodeResult QTextHtmlImporter::processSpecialNodes() { switch (currentNode->id) { case Html_body: if (currentNode->charFormat.background().style() != Qt::NoBrush) { QTextFrameFormat fmt = doc->rootFrame()->frameFormat(); fmt.setBackground(currentNode->charFormat.background()); doc->rootFrame()->setFrameFormat(fmt); const_cast<QTextHtmlParserNode *>(currentNode)->charFormat.clearProperty(QTextFormat::BackgroundBrush); } compressNextWhitespace = RemoveWhiteSpace; break; case Html_ol: case Html_ul: { QTextListFormat::Style style = currentNode->listStyle; if (currentNode->id == Html_ul && !currentNode->hasOwnListStyle && currentNode->parent) { const QTextHtmlParserNode *n = &at(currentNode->parent); while (n) { if (n->id == Html_ul) { style = nextListStyle(currentNode->listStyle); } if (n->parent) n = &at(n->parent); else n = 0; } } QTextListFormat listFmt; listFmt.setStyle(style); ++indent; if (currentNode->hasCssListIndent) listFmt.setIndent(currentNode->cssListIndent); else listFmt.setIndent(indent); List l; l.format = listFmt; l.listNode = currentNodeIdx; lists.append(l); compressNextWhitespace = RemoveWhiteSpace; // broken html: <ul>Text here<li>Foo const QString simpl = currentNode->text.simplified(); if (simpl.isEmpty() || simpl.at(0).isSpace()) return ContinueWithNextNode; break; } case Html_table: { Table t = scanTable(currentNodeIdx); tables.append(t); hasBlock = false; compressNextWhitespace = RemoveWhiteSpace; return ContinueWithNextNode; } case Html_tr: return ContinueWithNextNode; case Html_img: { QTextImageFormat fmt; fmt.setName(currentNode->imageName); fmt.merge(currentNode->charFormat); if (currentNode->imageWidth != -1) fmt.setWidth(currentNode->imageWidth); if (currentNode->imageHeight != -1) fmt.setHeight(currentNode->imageHeight); cursor.insertImage(fmt, QTextFrameFormat::Position(currentNode->cssFloat)); cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor); cursor.mergeCharFormat(currentNode->charFormat); cursor.movePosition(QTextCursor::Right); compressNextWhitespace = CollapseWhiteSpace; hasBlock = false; return ContinueWithNextNode; } case Html_hr: { QTextBlockFormat blockFormat = currentNode->blockFormat; blockFormat.setTopMargin(topMargin(currentNodeIdx)); blockFormat.setBottomMargin(bottomMargin(currentNodeIdx)); blockFormat.setProperty(QTextFormat::BlockTrailingHorizontalRulerWidth, currentNode->width); if (hasBlock && importMode == ImportToDocument) cursor.mergeBlockFormat(blockFormat); else appendBlock(blockFormat); hasBlock = false; compressNextWhitespace = RemoveWhiteSpace; return ContinueWithNextNode; } default: break; } return ContinueWithCurrentNode; }
inline const_reference operator[](size_type pos) const { return at(pos); }
void MergedTransactionTest::test_add_obsoleted_obsoleted() { return; /* def test_add_obsoleted_obsoleted(self): """Test add with an obsoleted NEVRA which was obsoleted before.""" ops = dnf.history.NEVRAOperations() ops.add( 'Install', 'tour-0:4.6-1.noarch', obsoleted_nevras=('lotus-0:3-16.x86_64', 'mrkite-0:2-0.x86_64') ) ops.add( 'Install', 'pepper-0:20-0.x86_64', obsoleted_nevras=('lotus-0:3-16.x86_64', 'librita-0:1-1.x86_64') ) self.assertCountEqual( ops, ( ( 'Install', 'tour-0:4.6-1.noarch', None, {'lotus-0:3-16.x86_64', 'mrkite-0:2-0.x86_64'} ), ( 'Install', 'pepper-0:20-0.x86_64', None, {'lotus-0:3-16.x86_64', 'librita-0:1-1.x86_64'} ) ) ) */ auto trans1 = std::make_shared< SwdbPrivate::Transaction >(conn); auto trans1_tour = trans1->addItem( nevraToRPMItem(conn, "tour-0:4.6-1.noarch"), "repo1", TransactionItemAction::INSTALL, TransactionItemReason::DEPENDENCY ); /* auto trans2 = std::make_shared< SwdbPrivate::Transaction >(conn); auto trans2_tour = trans2->addItem( nevraToRPMItem(conn, "tour-0:4.6-1.noarch"), "repo2", TransactionItemAction::INSTALL, TransactionItemReason::USER ); auto trans2_lotus = trans2->addItem(nevraToRPMItem(conn, "lotus-0:3-16.x86_64"), "repo1", TransactionItemAction::OBSOLETED, TransactionItemReason::DEPENDENCY); trans2_lotus->addReplacedBy(trans2_tour); */ MergedTransaction merged(trans1); //merged.merge(trans2); auto items = merged.getItems(); CPPUNIT_ASSERT_EQUAL(1, (int)items.size()); auto item = items.at(0); CPPUNIT_ASSERT_EQUAL(std::string("tour-4.6-1.noarch"), item->getRPMItem()->getNEVRA()); CPPUNIT_ASSERT_EQUAL(std::string("repo1"), item->getRepoid()); CPPUNIT_ASSERT_EQUAL(TransactionItemAction::INSTALL, item->getAction()); CPPUNIT_ASSERT_EQUAL(TransactionItemReason::DEPENDENCY, item->getReason()); }