void HelpIndexView::linksActivated(const QMap<QString,QUrl>& links, const QString& keyword) { HelpTopicChooser tc(m_IndexWidget, keyword, links); if (tc.exec() == QDialog::Accepted) { IWorkbenchPage::Pointer page = this->GetSite()->GetPage(); HelpPluginActivator::linkActivated(page, tc.link()); } }
std::vector<UnwrappedTileID> tileCover(const Geometry<double>& geometry, int32_t z) { std::vector<UnwrappedTileID> result; TileCover tc(geometry, z, true); while (tc.hasNext()) { result.push_back(*tc.next()); }; return result; }
DistQuery::TransactionContextPtr DistQuery::allocTransaction(TransactionContext::Type t) { TransactionContextPtr tc(new TransactionContext(*this)); tc->m_type = t; tc->m_tid = m_tid++; tc->m_stopWatch.start(); return tc; }
void QvisText2DInterface::textOpacityChanged(int opacity) { ColorAttribute tc(annot->GetTextColor()); tc.SetAlpha(opacity); annot->SetTextColor(tc); SetUpdate(false); Apply(); }
void QvisLine3DInterface::opacityChanged(int opacity) { ColorAttribute tc(annot->GetColor1()); tc.SetAlpha(opacity); annot->SetColor1(tc); SetUpdate(false); Apply(); }
uint64_t tileCount(const Geometry<double>& geometry, uint8_t z) { uint64_t tileCount = 0; TileCover tc(geometry, z, true); while (tc.next()) { tileCount++; }; return tileCount; }
void Foam::combustionModels::PaSR<Type>::correct() { if (this->active()) { const scalar t = this->mesh().time().value(); const scalar dt = this->mesh().time().deltaTValue(); if (!useReactionRate_) { this->chemistryPtr_->solve(t - dt, dt); } else { this->chemistryPtr_->calculate(); } if (turbulentReaction_) { tmp<volScalarField> trho(this->rho()); const volScalarField& rho = trho(); tmp<volScalarField> tepsilon(this->turbulence().epsilon()); const volScalarField& epsilon = tepsilon(); tmp<volScalarField> tmuEff(this->turbulence().muEff()); const volScalarField& muEff = tmuEff(); tmp<volScalarField> ttc(tc()); const volScalarField& tc = ttc(); forAll(epsilon, i) { if (epsilon[i] > 0) { scalar tk = Cmix_*Foam::sqrt(muEff[i]/rho[i]/(epsilon[i] + SMALL)); // Chalmers PaSR model if (!useReactionRate_) { kappa_[i] = (dt + tc[i])/(dt + tc[i] + tk); } else { kappa_[i] = tc[i]/(tc[i] + tk); } } else { // Return to laminar combustion kappa_[i] = 1.0; } } } else { kappa_ = 1.0; } }
bool LabelDialog::TransferDataToWindow() { int cnt = mData.size(); int i; // Set the editor parameters. Do this each time since they may change // due to NEW tracks and change in NumericTextCtrl format. Rate won't // change but might as well leave it here. mChoiceEditor->SetChoices(mTrackNames); mTimeEditor->SetFormat(mFormat); mTimeEditor->SetRate(mRate); // Disable redrawing until we're done mGrid->BeginBatch(); // Delete all rows if (mGrid->GetNumberRows()) { mGrid->DeleteRows(0, mGrid->GetNumberRows()); } // Add the exact number that we'll need mGrid->InsertRows(0, cnt); // Populate the rows for (i = 0; i < cnt; i++) { RowData &rd = mData[i]; // Set the cell contents mGrid->SetCellValue(i, Col_Track, TrackName(rd.index)); mGrid->SetCellValue(i, Col_Label, rd.title); mGrid->SetCellValue(i, Col_Stime, wxString::Format(wxT("%g"), rd.selectedRegion.t0())); mGrid->SetCellValue(i, Col_Etime, wxString::Format(wxT("%g"), rd.selectedRegion.t1())); // PRL: to do: -- populate future additional selection fields // and write event code to update them from controls } // Autosize all the rows mGrid->AutoSizeRows(true); // Resize the track name column. Use a wxChoice to determine the maximum // width needed. wxChoice tc(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, mTrackNames); mGrid->SetColSize(Col_Track, tc.GetSize().x); mGrid->SetColMinimalWidth(Col_Track, tc.GetSize().x); // Autosize the time columns and set their minimal widths mGrid->AutoSizeColumn(Col_Stime); mGrid->AutoSizeColumn(Col_Etime); // We're done, so allow the grid to redraw mGrid->EndBatch(); return true; }
bool PlayerServer::judgeResult(JudgeType type, std::unique_ptr<Card> &card) { unique_ptr<Card> tc(new Card(*card)); TRIEV(t_JudgeResult, &tc); bool b = Player::judgeResult(type, tc); TRIEV(t_JudgeResultEnd, &card); GAME->addToDeadwood(card); return b; }
void SanitiseTool::parseSpacers(xercesc::DOMElement * parentNode, crispr::xml::writer& xmlParser) { for (xercesc::DOMElement * currentElement = parentNode->getFirstElementChild(); currentElement != NULL; currentElement = currentElement->getNextElementSibling()) { if (xercesc::XMLString::equals(currentElement->getTagName(), xmlParser.tag_Spacer())) { char * c_spid = tc(currentElement->getAttribute(xmlParser.attr_Spid())); std::string spid = c_spid; ST_SpacerMap[spid] = getNextSpacerS(); xr(&c_spid); XMLCh * x_next_spacer_num = tc(getNextSpacerS().c_str()); currentElement->setAttribute(xmlParser.attr_Spid(), x_next_spacer_num); xr(&x_next_spacer_num); incrementSpacer(); } } }
bool KeywordsCompletionAssistProcessor::isInComment() const { QTextCursor tc(m_interface->textDocument()); tc.setPosition(m_interface->position()); tc.movePosition(QTextCursor::StartOfLine, QTextCursor::KeepAnchor); const QString &lineBeginning = tc.selectedText(); if (lineBeginning.contains(startOfCommentChar())) return true; return false; }
void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node) { TypeCompiler tc(m_session); tc.run(node->type_id->type_specifier); if (tc.isIntegral()) m_templateArgs << tc.qualifiedName().join(" "); else m_templateArgs << tc.qualifiedName().join("::"); // m_currentIdentifier.appendTemplateIdentifier( typeIdentifierFromTemplateArgument(m_session, node) ); }
vguard<set<Ontology::TermIndex> > Ontology::transitiveClosure() const { vguard<set<TermIndex> > tc (terms()); auto L = toposortTermIndex(); for (TermIndex n : L) { tc[n].insert (n); for (TermIndex p : parents[n]) tc[n].insert (tc[p].begin(), tc[p].end()); } return tc; }
bool IndexWindow::eventFilter(QObject *obj, QEvent *e) { if (obj == m_searchLineEdit && e->type() == QEvent::KeyPress) { QKeyEvent *ke = static_cast<QKeyEvent*>(e); QModelIndex idx = m_indexWidget->currentIndex(); switch (ke->key()) { case Qt::Key_Up: idx = m_indexWidget->model()->index(idx.row()-1, idx.column(), idx.parent()); if (idx.isValid()) m_indexWidget->setCurrentIndex(idx); break; case Qt::Key_Down: idx = m_indexWidget->model()->index(idx.row()+1, idx.column(), idx.parent()); if (idx.isValid()) m_indexWidget->setCurrentIndex(idx); break; case Qt::Key_Escape: MainWindow::activateCurrentCentralWidgetTab(); break; default: ; } } else if (obj == m_indexWidget && e->type() == QEvent::ContextMenu) { QContextMenuEvent *ctxtEvent = static_cast<QContextMenuEvent*>(e); QModelIndex idx = m_indexWidget->indexAt(ctxtEvent->pos()); if (idx.isValid()) { QMenu menu; QAction *curTab = menu.addAction(tr("Open Link")); QAction *newTab = menu.addAction(tr("Open Link in New Tab")); menu.move(m_indexWidget->mapToGlobal(ctxtEvent->pos())); QAction *action = menu.exec(); if (curTab == action) m_indexWidget->activateCurrentItem(); else if (newTab == action) { QHelpIndexModel *model = qobject_cast<QHelpIndexModel*>(m_indexWidget->model()); QString keyword = model->data(idx, Qt::DisplayRole).toString(); if (model) { QMap<QString, QUrl> links = model->linksForKeyword(keyword); if (links.count() == 1) { CentralWidget::instance()->setSourceInNewTab(links.constBegin().value()); } else { TopicChooser tc(this, keyword, links); if (tc.exec() == QDialog::Accepted) { CentralWidget::instance()->setSourceInNewTab(tc.link()); } } } } } } return QWidget::eventFilter(obj, e); }
TabId ContentProcessManager::AllocateTabId(const TabId& aOpenerTabId, const IPCTabContext& aContext, const ContentParentId& aChildCpId) { MOZ_ASSERT(NS_IsMainThread()); auto iter = mContentParentMap.find(aChildCpId); if (NS_WARN_IF(iter == mContentParentMap.end())) { ASSERT_UNLESS_FUZZING(); return TabId(0); } struct RemoteFrameInfo info; const IPCTabContextUnion& contextUnion = aContext.contextUnion(); // If it's a PopupIPCTabContext, it's the case that a TabChild want to // open a new tab. aOpenerTabId has to be it's parent frame's opener id. if (contextUnion.type() == IPCTabContextUnion::TPopupIPCTabContext) { auto remoteFrameIter = iter->second.mRemoteFrames.find(aOpenerTabId); if (remoteFrameIter == iter->second.mRemoteFrames.end()) { ASSERT_UNLESS_FUZZING("Failed to find parent frame's opener id."); return TabId(0); } info.mOpenerTabId = remoteFrameIter->second.mOpenerTabId; const PopupIPCTabContext &ipcContext = contextUnion.get_PopupIPCTabContext(); MOZ_ASSERT(ipcContext.opener().type() == PBrowserOrId::TTabId); remoteFrameIter = iter->second.mRemoteFrames.find(ipcContext.opener().get_TabId()); if (remoteFrameIter == iter->second.mRemoteFrames.end()) { ASSERT_UNLESS_FUZZING("Failed to find tab id."); return TabId(0); } info.mContext = remoteFrameIter->second.mContext; } else { MaybeInvalidTabContext tc(aContext); if (!tc.IsValid()) { NS_ERROR(nsPrintfCString("Received an invalid TabContext from " "the child process. (%s)", tc.GetInvalidReason()).get()); return TabId(0); } info.mOpenerTabId = aOpenerTabId; info.mContext = tc.GetTabContext(); } mUniqueId = ++gTabId; iter->second.mRemoteFrames[mUniqueId] = info; return mUniqueId; }
void DivRep::computeExactFlags() { if (!first->flagsComputed()) first->computeExactFlags(); if (!second->flagsComputed()) second->computeExactFlags(); if (!second->sign()) core_error("zero divisor.", __FILE__, __LINE__, true); if (!first->sign()) {// value must be exactly zero. reduceToZero(); return; } // rational node if (rationalReduceFlag) { if (first->ratFlag() > 0 && second->ratFlag() > 0) { BigRat val = (*(first->ratValue()))/(*(second->ratValue())); reduceToBigRat(val); ratFlag() = first->ratFlag() + second->ratFlag(); return; } else ratFlag() = -1; } // value is irrational. uMSB() = first->uMSB() - second->lMSB(); lMSB() = first->lMSB() - second->uMSB() - EXTLONG_ONE; sign() = first->sign() * second->sign(); extLong df = first->d_e(); extLong ds = second->d_e(); // extLong lf = first->length(); // extLong ls = second->length(); // length() = df * ls + ds * lf; measure() = (first->measure())*ds + (second->measure())*df; // BFMSS[2,5] bound. v2p() = first->v2p() + second->v2m(); v2m() = first->v2m() + second->v2p(); v5p() = first->v5p() + second->v5m(); v5m() = first->v5m() + second->v5p(); u25() = first->u25() + second->l25(); l25() = first->l25() + second->u25(); high() = first->high() + second->low(); low() = first->low() + second->high(); lc() = ds * first->lc() + df * second->tc(); tc() = core_min(ds * first->tc() + df * second->lc(), measure()); flagsComputed() = true; }
void UBTGAdaptableText::keyReleaseEvent(QKeyEvent* e) { QTextEdit::keyReleaseEvent(e); if(mMaximumLength && toPlainText().length()>mMaximumLength){ setPlainText(toPlainText().left(mMaximumLength)); QTextCursor tc(document()); tc.setPosition(mMaximumLength); setTextCursor(tc); } }
void TypeCompiler::visitParameterDeclaration(ParameterDeclarationAST* node) { TypeCompiler tc(m_session, m_visitor); tc.run(node->type_specifier, node->declarator); NameCompiler name_cc(m_session, m_visitor); if (tc.type().isFunctionPointer() && node->declarator && node->declarator->sub_declarator) name_cc.run(node->declarator->sub_declarator->id); else if (node->declarator) name_cc.run(node->declarator->id); m_realType.appendParameter(Parameter(name_cc.name(), Type::registerType(tc.type()))); }
void Bomb::DoDraw() const { if (!IsAlive()) return; const double tile_width_in_px = 16.0; const double tile_height_in_px = 16.0; TexCoords tc((470.0+tile_width_in_px*m_anim_frame_num), 16.0, tile_width_in_px, tile_height_in_px); Engine::Get().Renderer()->DrawSprite(tc, GetPosition()); if (g_render_aabbs) Engine::Get().Renderer()->DrawAABB(GetAABB()); }
void DrawTool::parseGroup(xercesc::DOMElement * parentNode, crispr::xml::parser& xmlParser) { // create a new graph object char * c_gid = tc(parentNode->getAttribute(xmlParser.attr_Gid())); crispr::graph * current_graph = new crispr::graph(c_gid); xr(&c_gid); // change the max and min coverages back to their original values resetInitialLimits(); DT_Graphs.push_back(current_graph); for (xercesc::DOMElement * currentElement = parentNode->getFirstElementChild(); currentElement != NULL; currentElement = currentElement->getNextElementSibling()) { if (xercesc::XMLString::equals(currentElement->getTagName(), xmlParser.tag_Data())) { parseData(currentElement, xmlParser, current_graph); setColours(); } else if (xercesc::XMLString::equals(currentElement->getTagName(), xmlParser.tag_Assembly())) { parseAssembly(currentElement, xmlParser, current_graph); } } char * c_file_prefix = tc(parentNode->getAttribute(xmlParser.attr_Gid())); std::string file_prefix = c_file_prefix; std::string file_name = file_prefix + "." + DT_OutputFormat; xr(&c_file_prefix); char * file_name_c = strdup(file_name.c_str()); layoutGraph(current_graph->getGraph(), DT_RenderingAlgorithm); renderGraphToFile(current_graph->getGraph(), DT_OutputFormat, file_name_c); freeLayout(current_graph->getGraph()); // free the duplicated string try { delete file_name_c; } catch (std::exception& e) { std::cerr<<e.what()<<std::endl; } }
void KisMacroTest::testCreation() { QList<KisRecordedAction*> actions; TestAction tc("bla", "bla", KisNodeQueryPath::fromString("/")); actions << &tc; const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8(); KisImageSP image = new KisImage(0, 512, 512, cs, "test"); KisMacro a(); KisMacro b(actions); }
int3 whereToExplore(HeroPtr h) { //TODO it's stupid and ineffective, write sth better cb->setSelection(*h); int radius = h->getSightRadious(); int3 hpos = h->visitablePos(); //look for nearby objs -> visit them if they're close enouh const int DIST_LIMIT = 3; std::vector<const CGObjectInstance *> nearbyVisitableObjs; for(const CGObjectInstance *obj : ai->getPossibleDestinations(h)) { int3 op = obj->visitablePos(); CGPath p; cb->getPath2(op, p); if(p.nodes.size() && p.endPos() == op && p.nodes.size() <= DIST_LIMIT) nearbyVisitableObjs.push_back(obj); } boost::sort(nearbyVisitableObjs, isCloser); if(nearbyVisitableObjs.size()) return nearbyVisitableObjs.back()->visitablePos(); try { return ai->explorationBestNeighbour(hpos, radius, h); } catch(cannotFulfillGoalException &e) { std::vector<std::vector<int3> > tiles; //tiles[distance_to_fow] try { return ai->explorationNewPoint(radius, h, tiles); } catch(cannotFulfillGoalException &e) { std::map<int, std::vector<int3> > profits; { TimeCheck tc("Evaluating exploration possibilities"); tiles[0].clear(); //we can't reach FoW anyway for(auto &vt : tiles) for(auto &tile : vt) profits[howManyTilesWillBeDiscovered(tile, radius)].push_back(tile); } if(profits.empty()) return int3 (-1,-1,-1); auto bestDest = profits.end(); bestDest--; return bestDest->second.front(); //TODO which is the real best tile? } } }
static qint64 getCorrection() { GCounter totalCounter("timer correction", "ticks", 1); TimeCounter tc(&totalCounter, false); tc.start(); tc.stop(); tc.start(); tc.stop(); tc.start(); tc.stop(); tc.start(); tc.stop(); qint64 correction = totalCounter.totalCount / 4; return correction; }
eFlag Tree::parse(Sit S, DataLine *d) { Log1(S, L1_PARSING, getURI()); double time_was = getMillisecs(); TreeConstructer tc(S); eFlag retval = tc.parseDataLineUsingExpat(S, this, d); if (!retval) { Log1(S, L1_PARSE_DONE, getMillisecsDiff(time_was)); } return retval; }
void Entity::render(const Map &map, const Camera &camera) const { m_program->bind(); m_program->setUniformValue(m_matrixUniform, camera.viewProjectionMatrix()); QVector3D up(0, 0.65 * m_scale, 0); QVector3D va = m_a; QVector3D vb = m_a + up; QVector3D vc = m_b + up; QVector3D vd = m_b; qreal dx = 1. / m_textureSize.width(); qreal dy = 1. / m_textureSize.height(); int index = m_angleIndex; if (m_walking) index += 8 + 8 * (m_animationIndex % 4); qreal tx1 = (m_tileWidth * (index % m_tileMod) + 1) * dx; qreal tx2 = tx1 + (m_tileWidth - 2) * dx; qreal ty1 = (m_tileHeight * (index / m_tileMod) + 1) * dy; qreal ty2 = ty1 + (m_tileHeight - 2) * dy; QVector2D ta(tx2, ty2); QVector2D tb(tx2, ty1); QVector2D tc(tx1, ty1); QVector2D td(tx1, ty2); QVector<QVector3D> vertexBuffer; vertexBuffer << va << vb << vd << vd << vb << vc; QVector<QVector3D> texBuffer; texBuffer << ta << tb << td << td << tb << tc; m_program->enableAttributeArray(m_vertexAttr); m_program->setAttributeArray(m_vertexAttr, vertexBuffer.constData()); m_program->enableAttributeArray(m_texAttr); m_program->setAttributeArray(m_texAttr, texBuffer.constData()); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_texture); glDrawArrays(GL_TRIANGLES, 0, 6); glDisable(GL_BLEND); m_program->disableAttributeArray(m_texAttr); m_program->disableAttributeArray(m_vertexAttr); }
void FltExportVisitor::writeUVList( int numVerts, const osg::Geometry& geom, const std::vector<unsigned int>& indices ) { unsigned int numLayers( 0 ); uint32 flags( 0 ); unsigned int idx; for( idx=1; idx<8; idx++) { if( isTextured( idx, geom ) ) { flags |= LAYER_1 >> (idx-1); numLayers++; } } if( numLayers == 0 ) return; uint16 length( 8 + (8*numLayers*numVerts) ); _records->writeInt16( (int16) UV_LIST_OP ); _records->writeUInt16( length ); _records->writeInt32( flags ); osg::Vec2 defaultCoord( 0., 0. ); // const osg::StateSet* ss = getCurrentStateSet(); for( int vertexIdx=0; vertexIdx<numVerts; vertexIdx++) { for( idx=1; idx<8; idx++) { if( isTextured( idx, geom ) ) { osg::Array* t = const_cast<osg::Array*>( geom.getTexCoordArray( idx ) ); osg::ref_ptr<osg::Vec2Array> t2 = dynamic_cast<osg::Vec2Array*>( t ); if (!t2.valid()) { std::ostringstream warning; warning << "fltexp: No Texture2D for unit " << idx; OSG_WARN << warning.str() << std::endl; _fltOpt->getWriteResult().warn( warning.str() ); t2 = new osg::Vec2Array; } const int size = t2->getNumElements(); int vIdx = indices[ vertexIdx ]; osg::Vec2& tc( defaultCoord ); if (vIdx < size) tc = ( *t2 )[ vIdx ]; _records->writeFloat32( tc[ 0 ] ); _records->writeFloat32( tc[ 1 ] ); } } } }
/*! SLMesh::preShade calculates the rest of the intersection information after the final hit point is determined. Should be called just before the shading when the final intersection point of the closest triangle was found. */ void SLMesh::preShade(SLRay* ray) { SLFace* hit = ray->hitTriangle; // calculate the hit point in world space ray->hitPoint.set(ray->origin + ray->length * ray->dir); // calculate the interpolated normal with vertex normals in object space ray->hitNormal.set(N[hit->iA] * (1-(ray->hitU+ray->hitV)) + N[hit->iB] * ray->hitU + N[hit->iC] * ray->hitV); // transform normal back to world space ray->hitNormal.set(ray->hitShape->wmN() * ray->hitNormal); // invert normal if the ray is inside a shape if (!ray->isOutside) ray->hitNormal *= -1; // for shading the normal is expected to be unit length ray->hitNormal.normalize(); // calculate interpolated texture coordinates SLVGLTexture& textures = ray->hitMat->textures(); if (textures.size() > 0) { SLVec2f Tu(Tc[hit->iB] - Tc[hit->iA]); SLVec2f Tv(Tc[hit->iC] - Tc[hit->iA]); SLVec2f tc(Tc[hit->iA] + ray->hitU*Tu + ray->hitV*Tv); ray->hitTexCol.set(textures[0]->getTexelf(tc.x,tc.y)); // bumpmapping if (textures.size() > 1) { if (T) { // calculate the interpolated tangent with vertex tangent in object space SLVec4f hitT(T[hit->iA] * (1-(ray->hitU+ray->hitV)) + T[hit->iB] * ray->hitU + T[hit->iC] * ray->hitV); SLVec3f T3(hitT.x,hitT.y,hitT.z); // tangent with 3 components T3.set(ray->hitShape->wmN() * T3); // transform tangent back to world space SLVec2f d = textures[1]->dsdt(tc.x,tc.y); // slope of bumpmap at tc SLVec3f N = ray->hitNormal; // unperturbated normal SLVec3f B(N^T3); // binormal tangent B B *= T[hit->iA].w; // correct handedness SLVec3f D(d.x*T3 + d.y*B); // perturbation vector D N+=D; N.normalize(); ray->hitNormal.set(N); } } } }
TEST(BaseCluster, Read) { std::stringstream input; tawara::UIntElement tc(tawara::ids::Timecode, 42); tawara::UIntElement st1(tawara::ids::SilentTrackNumber, 1); tawara::UIntElement st2(tawara::ids::SilentTrackNumber, 2); tawara::UIntElement ps(tawara::ids::PrevSize, 0x1234); FakeCluster e; std::streamsize body_size(tc.size()); tawara::vint::write(body_size, input); tc.write(input); EXPECT_EQ(tawara::vint::size(body_size) + body_size, e.read(input)); EXPECT_EQ(42, e.timecode()); EXPECT_TRUE(e.silent_tracks().empty()); EXPECT_EQ(0, e.previous_size()); body_size += tawara::ids::size(tawara::ids::SilentTracks) + tawara::vint::size(st1.size() + st2.size()) + st1.size() + st2.size() + ps.size(); tawara::vint::write(body_size, input); tc.write(input); tawara::ids::write(tawara::ids::SilentTracks, input); tawara::vint::write(st1.size() + st2.size(), input); st1.write(input); st2.write(input); ps.write(input); EXPECT_EQ(tawara::vint::size(body_size) + body_size, e.read(input)); EXPECT_EQ(42, e.timecode()); EXPECT_FALSE(e.silent_tracks().empty()); EXPECT_EQ(0x1234, e.previous_size()); // Body size value wrong (too small) input.str(std::string()); tawara::vint::write(2, input); tc.write(input); ps.write(input); EXPECT_THROW(e.read(input), tawara::BadBodySize); // Invalid child input.str(std::string()); tawara::UIntElement ue(tawara::ids::EBML, 0xFFFF); tawara::vint::write(ue.size(), input); ue.write(input); EXPECT_THROW(e.read(input), tawara::InvalidChildID); // Missing timecode input.str(std::string()); tawara::vint::write(ps.size(), input); ps.write(input); EXPECT_THROW(e.read(input), tawara::MissingChild); }
void MainWindow::on_time(){ QTime time=QTime(0,0,0,0); time=time.addMSecs(videoPlayer->currentTime()); if(sub!=NULL){ QString replic(""); TimeConteiner tc(time,time); replic=sub->value(tc,replic).trimmed(); if(replic!=subtitles->toPlainText().trimmed()){ subtitles->setText(replic); } } ui->label->setText(time.toString("hh:mm:ss")); }
void info_manager::get_info_record(environment const & env, options const & o, io_state const & ios, pos_info pos, json & record, std::function<bool (info_data const &)> pred) const { type_context_old tc(env, o); io_state_stream out = regular(env, ios, tc).update_options(o); get_line_info_set(pos.first).for_each([&](unsigned c, list<info_data> const & ds) { if (c == pos.second) { for (auto const & d : ds) { if (!pred || pred(d)) d.report(out, record); } } }); }