QVariant NewsFeedModel::data(const QModelIndex &index, int role) const
{
int row = index.row();
auto news = m_newsList.at(row);
switch (role) {
case TypeRole:
return news.type();
case PostIdRole:
return news.postId();
break;
case SourceRole: {
int source = news.sourceId();
return qVariantFromValue(findContact(source));
}
case DateRole:
return news.date();
case BodyRole:
return news.body();
case AttachmentsRole:
return vk::Attachment::toVariantMap(news.attachments());
case LikesRole:
return news.likes();
case RepostsRole:
return news.reposts();
case CommentsRole:
return news.property("comments");
case OwnerNameRole: {
int ownerId = news.property("copy_owner_id").toInt();
if (ownerId) {
auto contact = findContact(ownerId);
return contact->name();
}
return QVariant();
}
case SourcePhotoRole: {
if (auto contact = findContact(news.sourceId()))
return contact->photoSource();
break;
}
case SourceNameRole: {
if (auto contact = findContact(news.sourceId()))
return contact->name();
break;
}
case LikesCount: {
return news.likes().value("count").toInt();
}
case CommentsCount:
return news.property("comments").toMap().value("count").toInt();
default:
break;
}
return QVariant::Invalid;
}
void State_t::LoadFromXmlNode(CTextNode& node, Agent* pAgent)
{
if (pAgent)
{
CSerializationID membersId("members");
ISerializableNode* membersNode = node.findChild(membersId);
pAgent->Load(membersNode);
}
this->m_vars.Load(&node);
CSerializationID btNodeId("BehaviorTree");
ISerializableNode* btNode = node.findChild(btNodeId);
if (btNode)
{
CSerializationID sourceId("source");
behaviac::string btName;
if (btNode->getAttr(sourceId, btName))
{
BEHAVIAC_DELETE this->m_bt;
this->m_bt = Workspace::GetInstance()->CreateBehaviorTreeTask(btName.c_str());
}
CSerializationID nodeId("node");
ISerializableNode* n = btNode->findChild(nodeId);
BEHAVIAC_ASSERT(n);
this->m_bt->Load(n);
}
}
bool Message::operator== (const Message& rValue) const
{
if (severity() != rValue.severity()) return false;
if (sourceId() != rValue.sourceId()) return false;
if (line() != rValue.line()) return false;
if (column() != rValue.column()) return false;
if (text() != rValue.text()) return false;
return true;
}
void NewsFeedModel::deleteLike(int postId)
{
int index = findNews(postId);
if (index != -1) {
auto news = m_newsList.at(index);
auto reply = m_client.data()->deleteLike(news.sourceId(),
postId);
connect(reply, SIGNAL(resultReady(QVariant)), SLOT(onDeleteLike(QVariant)));
}
}
void NewsFeedModel::addLike(int postId, bool retweet, const QString &message)
{
int index = findNews(postId);
if (index != -1) {
auto news = m_newsList.at(index);
auto reply = m_client.data()->addLike(news.sourceId(),
postId,
retweet,
message);
connect(reply, SIGNAL(resultReady(QVariant)), SLOT(onAddLike(QVariant)));
}
}
void BehaviorTreeTask::Save(ISerializableNode* node) const
{
CSerializationID btId("BehaviorTree");
ISerializableNode* btNodeRoot = node->newChild(btId);
BEHAVIAC_ASSERT(BehaviorTree::DynamicCast(this->GetNode()));
BehaviorTree* bt = (BehaviorTree*)this->GetNode();
CSerializationID sourceId("source");
btNodeRoot->setAttr(sourceId, bt->GetName());
CSerializationID nodeId("node");
ISerializableNode* btNode = btNodeRoot->newChild(nodeId);
this->save(btNode);
}
inline QString sourceKey(const qint32& idx)
{ return QString("/Sources/%1").arg(sourceId(idx));}
bool QSEngineImp::evaluate( const QString &code, const QSObject *thisV,
bool onlyCheckSyntax, int checkMode, int lineZero )
{
#if defined (QT_THREAD_SUPPORT) && QT_VERSION >= 0x030300
QMutex *mutex = qt_global_mutexpool ? qt_global_mutexpool->get(qApp) : 0;
#endif
QS_MUTEX_LOCK;
QSProgramNode *progNode = 0;
init();
#ifdef QSDEBUGGER
incrSourceId();
if (debugger())
debugger()->setSourceId(sid);
#endif
if (recursion > 7) {
qWarning( "QtScript: breaking out of recursion" );
QS_MUTEX_UNLOCK;
return true;
}
assert(QSLexer::lexer());
{
QSLexer::lexer()->setCode( code,
#ifdef QSDEBUGGER
sourceId(),
#else
0,
#endif
lineZero );
int parseError = qsyyparse();
progNode = QSProgramNode::last();
if( parseError || QSLexer::lexer()->lexerState() == QSLexer::Bad ) {
errType = QSErrParseError;
int l = QSLexer::lexer()->lineNo();
errLines.append( l );
errMsgs.append( QString::fromLatin1("Parse Error: ")
+ qs_format_error( QSLexer::lexer()->errorMessage() ) );
/* TODO: either clear everything or keep previously
parsed function definitions */
// QSNode::deleteAllNodes();
if (progNode && progNode->deref()) {
delete progNode;
}
QS_MUTEX_UNLOCK;
return false;
}
}
QSCheckData sem( env(), env()->globalClass() );
if ( thisV ) {
Q_ASSERT( thisV->isValid() );
// qDebug( "QSEngineImp::evaluate: entering %s",
// thisV->typeName().latin1());
sem.enterClass( (QSClass*)thisV->objectType() );
env()->pushScope( *thisV );
}
sem.setGlobalStatementsForbidden( checkMode & QSEngine::DisallowGlobal );
progNode->check( &sem );
if ( sem.hasError() ) {
errType = sem.errorCode();
errLines = sem.errorLines();
errMsgs = sem.errorMessages();
if (progNode->deref())
delete progNode;
QS_MUTEX_UNLOCK;
return FALSE;
}
if (onlyCheckSyntax) {
if (progNode->deref()) {
delete progNode;
}
QS_MUTEX_UNLOCK;
return true;
}
env()->clearException();
recursion++;
assert(progNode);
QS_MUTEX_UNLOCK;
QSObject res = progNode->execute( env() );
QS_MUTEX_LOCK;
recursion--;
if ( env()->isExceptionMode( )) {
QSObject err = env()->exception();
errType = 99; /* TODO */
errLines.append(QSErrorClass::errorLine(&err));
errMsgs.append(QSErrorClass::errorName(&err) + QString::fromLatin1(". ") + QSErrorClass::errorMessage(&err));
#ifdef QSDEBUGGER
if (dbg)
dbg->setSourceId(QSErrorClass::errorSourceId(&err));
#endif
env()->clearException();
} else {
errType = 0;
errLines.clear();
errMsgs.clear();
// catch return value
retVal = res;
}
if ( thisV ) {
env()->popScope();
}
if (progNode->deref()) {
delete progNode;
}
QS_MUTEX_UNLOCK;
return !errType;
}
// ---------------------------------------------------------------------------
// CTestDtmf::TestStreamControlL
// ---------------------------------------------------------------------------
//
void CTestDtmf::TestStreamControlL( TDtmfSignalType aSigType )
{
TMccNetSettings tempSettings = iNetsettings;
CMccInterfaceStub* stub = CMccInterfaceStub::NewL();
CleanupStack::PushL( stub );
CMccInterface* interface = CMccInterface::NewL( *stub );
CleanupStack::PushL( interface );
TUint32 sessionId;
User::LeaveIfError( interface->CreateSession( sessionId ) );
TUint32 linkId;
TInt linkType( KMccLinkGeneral );
User::LeaveIfError( interface->CreateLink( sessionId, linkType, linkId,
tempSettings ) );
stub->WaitForEvent( sessionId, linkId, 0, KMccLinkCreated );
CMccCodecInformation* cInfo
= FetchCodecByMimeSubtypeNameL( *interface, KTxtDtmf );
CleanupStack::PushL( cInfo );
if ( aSigType == EInbandSignal )
{
cInfo->SetCodecMode( EDTMFModeInband );
}
else
{
cInfo->SetCodecMode( EDTMFModeEvent );
}
TUint32 streamId( 0 );
TUint32 sinkId( 0 ), sourceId( 0 );
interface->AddDataSink( KMccRtpSinkUid, KNullDesC8, sinkId );
interface->AddDataSource( KMccRtpSourceUid, KNullDesC8, sourceId );
User::LeaveIfError( interface->CreateStream( sessionId, linkId, streamId,
KMccDtmfStream, *cInfo ) );
// TEST CORRECT CONTROL PATHS
User::LeaveIfError ( interface->PrepareStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPrepared );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPrepared );
User::LeaveIfError ( interface->StartStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStarted );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStarted );
User::LeaveIfError ( interface->PauseStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPaused );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamPaused );
User::LeaveIfError ( interface->ResumeStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamResumed );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamResumed );
User::LeaveIfError ( interface->StopStream( sessionId, linkId, streamId ) );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStopped );
stub->WaitForEvent( sessionId, linkId, streamId, KMccStreamStopped );
// TBD: TEST INVALID CONTROL PATHS
User::LeaveIfError( interface->DeleteStream( sessionId, linkId, streamId ) );
User::LeaveIfError( interface->CloseLink( sessionId, linkId ) );
User::LeaveIfError( interface->CloseSession( sessionId ) );
CleanupStack::PopAndDestroy( cInfo );
CleanupStack::PopAndDestroy( interface );
CleanupStack::PopAndDestroy( stub );
}
