sttx::pointer transactionmaster::fetch (shamapitem::ref item,
shamaptreenode::tntype type,
bool checkdisk, std::uint32_t ucommitledger)
{
sttx::pointer txn;
transaction::pointer itx = getapp().getmastertransaction ().fetch (item->gettag (), false);
if (!itx)
{
if (type == shamaptreenode::tntransaction_nm)
{
serializeriterator sit (item->peekserializer ());
txn = std::make_shared<sttx> (std::ref (sit));
}
else if (type == shamaptreenode::tntransaction_md)
{
serializer s;
int length;
item->peekserializer ().getvl (s.moddata (), 0, length);
serializeriterator sit (s);
txn = std::make_shared<sttx> (std::ref (sit));
}
}
else
{
if (ucommitledger)
itx->setstatus (committed, ucommitledger);
txn = itx->getstransaction ();
}
return txn;
}
QTodoListItemsSorter::QTodoListItemsSorter(QPtrList<QWidget>* _input,const QTodoSortCriteriaMap* sort_criterias)
{ //FIXME: not yet section ready
//1. get sub lists
//2. sort sub lists
//3. connect to big list
//4. return it
input = _input;
std::map<int,QTodoItemSortPtrList* > lists;
QPtrListIterator<QWidget> it(*input);
int sub_counter = 0;
for(;it.current() || it.atFirst();++it)
{
if(QTodoItemSortPtrList* sub_list = getSubList(it))
{
lists[sub_counter] = sub_list;
++sub_counter;
}
}
for(std::map<int,QTodoItemSortPtrList* >::iterator it = lists.begin(); it != lists.end(); ++it)
{
(*it).second->setSortCriterias(sort_criterias);
(*it).second->sort();
}
QPtrList<QWidget>* big_list = new QPtrList<QWidget>;
for(std::map<int,QTodoItemSortPtrList* >::iterator it = lists.begin(); it != lists.end(); ++it)
{
if(!(*it).second->top_item)
{
QPtrListIterator<QTodoItem> sit(*(*it).second);
for(; sit.current(); ++sit)
big_list->append(sit.current());
}
else
{
int pos = big_list->find((*it).second->top_item)+1;
QPtrListIterator<QTodoItem> sit(*(*it).second);
sit.toLast();
for(; sit.current(); --sit)
big_list->insert(pos,sit.current());
}
}
output = big_list;
}
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, time_duration& td)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get(sit, str_end, is, td);
}
}
catch(...) {
std::ios_base::iostate exception_mask = is.exceptions();
if(std::ios_base::failbit & exception_mask) {
try { is.setstate(std::ios_base::failbit); }
catch(std::ios_base::failure&) {}
throw; // rethrow original exception
}
else {
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
static type make(const View& src, int n) {
typedef typename type::xy_locator locator_t;
typedef typename type::x_iterator x_iterator_t;
typedef typename iterator_adaptor_get_base<x_iterator_t>::type x_iterator_base_t;
x_iterator_t sit(x_iterator_base_t(&(src(0,0)[n])),src.pixels().pixel_size());
return type(src.dimensions(),locator_t(sit, src.pixels().row_size()));
}
bool glStaticMovesRobot::demo ( )
{
static int move_number = 5;
switch (move_number)
{
case 5 : stand( ); break;
case 6 : sit ( ); break;
case 7 : squat( 90 ); break;
case 8 : one_knee_kneel(true); break;
case 9 : kneel( ); break;
case 10 : arms_down_by_side ( ); break;
case 11 : w_question ( ); break;
case 12 : hands_on_hip ( ); break;
case 13 : folded_arms ( ); break;
case 14 : zombie_arms ( ); break;
case 15 : arm_straight_up ( true ); break;
case 16 : arm_straight_up ( false ); break;
case 17 : wave_1 ( true ); break;
case 18 : wave_2 ( true ); break;
case 19 : arm_stretched_to_side_left ( ); break;
case 20 : arm_stretched_to_side_right( ); break;
case 21 : attention_1 ( ); break;
case 22 : attention_2 ( ); break;
case 23 : move_number = 1.; return true; break;
default: break;
}
move_number++;
return false;
}
void KviRegisteredChannelDataBase::load(const QString &filename)
{
KviConfigurationFile cfg(filename,KviConfigurationFile::Read);
qDeleteAll(*m_pChannelDict);
m_pChannelDict->clear();
KviConfigurationFileIterator it(*(cfg.dict()));
while(KviConfigurationFileGroup * d = it.current())
{
QString szMask = it.currentKey();
QString szChan = KviQString::leftToLast(szMask,QChar('@'),false);
KviQString::cutToLast(szMask,QChar('@'),true);
KviRegisteredChannel * c = new KviRegisteredChannel(szChan,szMask);
add(c);
KviConfigurationFileGroupIterator sit(*d);
while(QString * s = sit.current())
{
c->setProperty(sit.currentKey(),*s);
++sit;
}
++it;
}
}
std::shared_ptr<STTx const>
sterilize (STTx const& stx)
{
Serializer s;
stx.add(s);
SerialIter sit(s.slice());
return std::make_shared<STTx const>(std::ref(sit));
}
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, local_date_time& ldt)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename local_date_time::utc_time_type utc_time_type;
typedef typename date_time::time_input_facet<utc_time_type, CharT> time_input_facet;
// intermediate objects
std::basic_string<CharT> tz_str;
utc_time_type pt(not_a_date_time);
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get_local_time(sit, str_end, is, pt, tz_str);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get_local_time(sit, str_end, is, pt, tz_str);
}
if(tz_str.empty()) {
time_zone_ptr null_ptr;
// a null time_zone_ptr creates a local_date_time that is UTC
ldt = local_date_time(pt, null_ptr);
}
else {
time_zone_ptr tz_ptr(new posix_time_zone(date_time::convert_string_type<CharT,char>(tz_str)));
// the "date & time" constructor expects the time label to *not* be utc.
// a posix_tz_string also expects the time label to *not* be utc.
ldt = local_date_time(pt.date(), pt.time_of_day(), tz_ptr, local_date_time::EXCEPTION_ON_ERROR);
}
}
catch(...) {
// mask tells us what exceptions are turned on
std::ios_base::iostate exception_mask = is.exceptions();
// if the user wants exceptions on failbit, we'll rethrow our
// date_time exception & set the failbit
if(std::ios_base::failbit & exception_mask) {
try {
is.setstate(std::ios_base::failbit);
}
catch(std::ios_base::failure&) {} // ignore this one
throw; // rethrow original exception
}
else {
// if the user want's to fail quietly, we simply set the failbit
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
stledgerentry::stledgerentry (
const serializer& s, uint256 const& index)
: stobject (sfledgerentry), mindex (index), mmutable (true)
{
// we know 's' isn't going away
serializeriterator sit (const_cast<serializer&> (s));
set (sit);
setsletype ();
}
void FermionBase::copySPOs(spo_set_type& spos)
{
spo_set_type::const_iterator sit(spos.begin());
while (sit != spos.end())
{
addSPO((*sit).first, (*sit).second);
++sit;
}
}
void FermionBase::resetSPOs(ParticleSet& P)
{
map<string, SPOSetBasePtr>::iterator sit(mySPOSet.begin());
while (sit != mySPOSet.end())
{
(*sit).second->resetTargetParticleSet(P);
++sit;
}
}
void PhotoDialog::resetComments()
{
QSetIterator<PhotoCommentItem*> sit(mComments);
//QLayout* l = ui->scrollAreaWidgetContents->layout();
while(sit.hasNext())
{
PhotoCommentItem* item = sit.next();
ui->verticalLayout->insertWidget(0,item);
}
}
void FermionBase::cloneSPOs(const spo_set_type& spos, ParticleSet& tqp)
{
spo_set_type::const_iterator sit(spos.begin());
while (sit != spos.end())
{
SPOSetBasePtr spo = (*sit).second;
addSPO((*sit).first, spo->makeClone());
++sit;
}
}
value_type
dereference() const override
{
value_type result;
{
SerialIter sit(
iter_->second.first->slice());
result.first = std::make_shared<
STTx const>(sit);
}
if (metadata_)
{
SerialIter sit(
iter_->second.second->slice());
result.second = std::make_shared<
STObject const>(sit, sfMetadata);
}
return result;
}
int eServiceFS::getServiceTypeForExtension(const std::string &str)
{
for (std::map<int, std::list<std::string> >::iterator sit(m_additional_extensions.begin()); sit != m_additional_extensions.end(); ++sit)
{
for (std::list<std::string>::iterator eit(sit->second.begin()); eit != sit->second.end(); ++eit)
{
if (*eit == str)
return sit->first;
}
}
return -1;
}
int eServiceCenter::getServiceTypeForExtension(const char *str)
{
for (std::map<int, std::list<std::string> >::iterator sit(extensions.begin()); sit != extensions.end(); ++sit)
{
for (std::list<std::string>::iterator eit(sit->second.begin()); eit != sit->second.end(); ++eit)
{
if (*eit == str)
return sit->first;
}
}
return -1;
}
void PhotoDialog::clearComments()
{
//QLayout* l = ui->scrollAreaWidgetContents->layout();
QSetIterator<PhotoCommentItem*> sit(mComments);
while(sit.hasNext())
{
PhotoCommentItem* item = sit.next();
ui->verticalLayout->removeWidget(item);
item->setParent(NULL);
delete item;
}
mComments.clear();
}
RESULT eServiceCenter::removeServiceFactory(int id)
{
for (std::map<std::string, int>::iterator sit(extensions_r.begin()); sit != extensions_r.end(); )
{
if (sit->second == id)
{
extensions_r.erase(sit++);
}
else
{
++sit;
}
}
handler.erase(id);
return 0;
}
Transaction::pointer Transaction::sharedTransaction(const std::vector<unsigned char>&vucTransaction, bool bValidate)
{
try
{
Serializer s(vucTransaction);
SerializerIterator sit(s);
SerializedTransaction::pointer st = boost::make_shared<SerializedTransaction>(boost::ref(sit));
return boost::make_shared<Transaction>(st, bValidate);
}
catch (...)
{
Log(lsWARNING) << "Exception constructing transaction";
return boost::shared_ptr<Transaction>();
}
}
std::string
debugTostr (SHAMap const& set)
{
std::stringstream ss;
for (auto const& item : set)
{
try
{
SerialIter sit(item.slice());
auto const tx = std::make_shared<
STTx const>(sit);
ss << debugTxstr(tx) << ", ";
}
catch(std::exception const&)
{
ss << "THRO, ";
}
}
return ss.str();
}
inline
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, ptime& pt)
{
boost::io::ios_flags_saver iflags(is);
typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
if (strm_sentry) {
try {
typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
if(std::has_facet<time_input_facet>(is.getloc())) {
std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
}
else {
time_input_facet* f = new time_input_facet();
std::locale l = std::locale(is.getloc(), f);
is.imbue(l);
f->get(sit, str_end, is, pt);
}
}
catch(...) {
// mask tells us what exceptions are turned on
std::ios_base::iostate exception_mask = is.exceptions();
// if the user wants exceptions on failbit, we'll rethrow our
// date_time exception & set the failbit
if(std::ios_base::failbit & exception_mask) {
try { is.setstate(std::ios_base::failbit); }
catch(std::ios_base::failure&) {} // ignore this one
throw; // rethrow original exception
}
else {
// if the user want's to fail quietly, we simply set the failbit
is.setstate(std::ios_base::failbit);
}
}
}
return is;
}
void
OMR::SymbolReference::setAliasedTo(TR_BitVector &bv, TR::SymbolReferenceTable *symRefTab, bool symmetric)
{
TR::Compilation *comp = symRefTab->comp();
TR_ASSERT(_useDefAliases, "this symref doesn't have its own aliasing bitvector");
if (!symmetric)
{
*_useDefAliases |= bv;
}
else
{
// we must process one by one to ensure symmetric aliasing
TR_SymRefIterator sit(bv, symRefTab);
for (TR::SymbolReference *symRef = sit.getNext();
symRef;
symRef = sit.getNext())
{
self()->setAliasedTo(symRef, true);
}
}
}
std::pair<std::shared_ptr<
STTx const>, std::shared_ptr<
STObject const>>
deserializeTxPlusMeta (SHAMapItem const& item)
{
std::pair<std::shared_ptr<
STTx const>, std::shared_ptr<
STObject const>> result;
SerialIter sit(item.slice());
{
SerialIter s(sit.getSlice(
sit.getVLDataLength()));
result.first = std::make_shared<
STTx const>(s);
}
{
SerialIter s(sit.getSlice(
sit.getVLDataLength()));
result.second = std::make_shared<
STObject const>(s, sfMetadata);
}
return result;
}
void LWF::ExecMovieCommand()
{
if (m_movieCommands.empty())
return;
vector<int> deletes;
int i = 0;
MovieCommands::iterator
it(m_movieCommands.begin()), itend(m_movieCommands.end());
for (; it != itend; ++it) {
bool available = true;
Movie *movie = rootMovie.get();
vector<string>::iterator
sit(it->first.begin()), sitend(it->first.end());
for (; sit != sitend; ++sit) {
movie = movie->SearchMovieInstance(*sit);
if (!movie) {
available = false;
break;
}
}
if (available) {
it->second(movie);
deletes.push_back(i);
}
++i;
}
for (vector<int>::reverse_iterator rit = deletes.rbegin();
rit != deletes.rend(); ++rit) {
it = m_movieCommands.begin();
advance(it, *rit);
m_movieCommands.erase(it);
}
}
void Task::run() {
QTcpSocket socket;
QString answerID,type,lang;
socket.setSocketDescriptor(this->socketDescriptor);
socket.waitForReadyRead();
data=socket.readAll();
dateTime = QDateTime::currentDateTime();
QStringList params;
QFile file;
token=QUuid::createUuid().toString();
token=token.left(token.size()-1);
token=token.right(token.size()-1);
conName=cdb.connectionName()+QString::number(id);
{
QSqlDatabase db=QSqlDatabase(QSqlDatabase::cloneDatabase(cdb,conName));
db.open();
QSqlQuery query(db);
sc = engine.evaluate("(" + QString(data) + ")");
QScriptValueIterator it(sc);
while (it.hasNext()) {
it.next();
if (it.name()=="program")
{
program_id=it.value().toString();
token=token+"-"+program_id;
params<<program_id;
if (!params.at(0).isNull()||!params.at(0).isEmpty())
{
query.exec("INSERT INTO math.answer (an_user_id, an_token, an_complete, an_start_date, an_cp_id) VALUES (0, '"+token+"', 0, '"+dateTime.toString("yyyy-MM-dd hh:mm:ss")+"', '"+program_id+"');");
query.exec("SELECT @an_id:=LAST_INSERT_ID();");
query.next();
answerID = query.value(0).toString();
params<<answerID;
}
}
if (it.name()=="exec")
{
type=it.value().toString();
}
if (it.name()=="lang")
{
lang=it.value().toString();
params<<lang;
}
if (it.value().isObject())
{
if (type=="execute")
{
QScriptValueIterator sit(it.value());
while (sit.hasNext()) {
sit.next();
if (sit.value().isObject())//--- jeigu tai failas
{
QScriptValueIterator sits(sit.value());
while (sits.hasNext()) {
sits.next();
if (sits.value().toString()=="file")
{
sits.next();
query.exec("SELECT @pp_id:=pp_id FROM math.program_param_list,math.program_param WHERE ppl_pp_id=pp_id and ppl_cp_id="+program_id+" and pp_name='"+sits.name()+"'");
cout << program_id.toStdString() << " program id \n";
query.prepare("INSERT INTO math.answer_param_value (pv_value, pv_pp_id) VALUES (:val, @pp_id);");
query.bindValue(":val",sits.value().toString());
query.exec();
query.exec("SELECT @pv_id:=LAST_INSERT_ID();");
query.exec("INSERT INTO math.answer_param_list (anpl_an_id, anpl_pv_id) VALUES (@an_id, @pv_id)");
query.exec("SELECT BD_DATA FROM math.big_data where BD_ID="+sits.value().toString());
query.next();
file.setFileName(this->binaryPath+"/binaries/"+program_id+"/"+sits.value().toString());
params<<this->binaryPath+"/binaries/"+program_id+"/"+sits.value().toString();
if (file.open(QIODevice::WriteOnly | QIODevice::Text))
{
QTextStream out(&file);
out << query.value(0).toByteArray();
}
file.close();
}
}
}
else {
params<<sit.value().toString();
query.exec("SELECT @pp_id:=pp_id FROM math.program_param_list,math.program_param WHERE ppl_pp_id=pp_id and ppl_cp_id="+program_id+" and pp_name='"+sit.name()+"'");
query.prepare("INSERT INTO math.answer_param_value (pv_value, pv_pp_id) VALUES (:val, @pp_id);");
query.bindValue(":val",sit.value().toString());
query.exec();
query.exec("SELECT @pv_id:=LAST_INSERT_ID();");
query.exec("INSERT INTO math.answer_param_list (anpl_an_id, anpl_pv_id) VALUES (@an_id, @pv_id)");
}
}
}
}
}
}
QSqlDatabase::removeDatabase(conName);
if (type=="execute")
{
if (params.at(0).isNull()||params.at(0).isEmpty())
{
socket.write("Nurodykite programa");
socket.waitForBytesWritten();
}
else emit this->requestExecute(params);
}
if (type=="compile")
{
if (params.at(0).isNull()||params.at(0).isEmpty())
{
socket.write("Nurodykite programa");
socket.waitForBytesWritten();
}
else emit this->requestCompile(params);
}
// qDebug()<<QString(data);
socket.write(token.toLatin1());
socket.flush();
socket.waitForBytesWritten();
socket.waitForDisconnected();
socket.close();
}
void NetworkView::updateDisplay()
{
if(!isVisible())
return ;
if(!_should_update)
return ;
/* add all friends */
std::string ownGPGId = rsPeers->getGPGOwnId();
//#ifdef DEBUG_NETWORKVIEW
std::cerr << "NetworkView::updateDisplay()" << std::endl;
//#endif
std::deque<NodeInfo> nodes_to_treat ; // list of nodes to be treated. Used as a queue. The int is the level of friendness
std::set<std::string> nodes_considered ; // list of nodes already considered. Eases lookup.
nodes_to_treat.push_front(NodeInfo(ownGPGId,0)) ; // initialize queue with own id.
nodes_considered.insert(rsPeers->getOwnId()) ;
// Put own id in queue, and empty the queue, treating all nodes.
//
while(!nodes_to_treat.empty())
{
NodeInfo info(nodes_to_treat.back()) ;
nodes_to_treat.pop_back() ;
#ifdef DEBUG_NETWORKVIEW
std::cerr << " Poped out of queue: " << info.gpg_id << ", with level " << info.friend_level << std::endl ;
#endif
GraphWidget::NodeType type ;
GraphWidget::AuthType auth ;
switch(info.friend_level)
{
case 0:
type = GraphWidget::ELASTIC_NODE_TYPE_OWN ;
break ;
case 1:
type = GraphWidget::ELASTIC_NODE_TYPE_FRIEND ;
break ;
case 2:
type = GraphWidget::ELASTIC_NODE_TYPE_F_OF_F ;
break ;
default:
type = GraphWidget::ELASTIC_NODE_TYPE_UNKNOWN ;
}
RsPeerDetails detail ;
if(!rsPeers->getPeerDetails(info.gpg_id, detail))
continue ;
switch(detail.trustLvl)
{
case RS_TRUST_LVL_MARGINAL:
auth = GraphWidget::ELASTIC_NODE_AUTH_MARGINAL ;
break;
case RS_TRUST_LVL_FULL:
case RS_TRUST_LVL_ULTIMATE:
auth = GraphWidget::ELASTIC_NODE_AUTH_FULL ;
break;
case RS_TRUST_LVL_UNKNOWN:
case RS_TRUST_LVL_UNDEFINED:
case RS_TRUST_LVL_NEVER:
default:
auth = GraphWidget::ELASTIC_NODE_AUTH_UNKNOWN ;
break ;
}
if(info.friend_level <= _max_friend_level && _node_ids.find(info.gpg_id) == _node_ids.end())
{
_node_ids[info.gpg_id] = ui.graphicsView->addNode(" "+detail.name, detail.name+"@"+detail.gpg_id,type,auth,"",info.gpg_id);
#ifdef DEBUG_NETWORKVIEW
std::cerr << " inserted node " << info.gpg_id << ", type=" << type << ", auth=" << auth << std::endl ;
#endif
}
std::list<std::string> friendList;
rsDisc->getDiscGPGFriends(info.gpg_id, friendList);
#ifdef DEBUG_NETWORKVIEW
std::cerr << " Got a list of " << friendList.size() << " friends for this peer." << std::endl ;
#endif
if(info.friend_level+1 <= _max_friend_level)
for(std::list<std::string>::const_iterator sit(friendList.begin()); sit != friendList.end(); ++sit)
if(nodes_considered.find(*sit) == nodes_considered.end())
{
#ifdef DEBUG_NETWORKVIEW
std::cerr << " adding to queue: " << *sit << ", with level " << info.friend_level+1 << std::endl ;
#endif
nodes_to_treat.push_front( NodeInfo(*sit,info.friend_level + 1) ) ;
nodes_considered.insert(*sit) ;
}
}
/* iterate through all friends */
#ifdef DEBUG_NETWORKVIEW
std::cerr << "NetworkView::insertSignatures()" << std::endl;
#endif
for(std::map<std::string,GraphWidget::NodeId>::const_iterator it(_node_ids.begin()); it != _node_ids.end(); it++)
{
std::list<std::string> friendList ;
if(rsDisc->getDiscGPGFriends(it->first,friendList))
for(std::list<std::string>::const_iterator sit(friendList.begin()); sit != friendList.end(); sit++)
{
#ifdef DEBUG_NETWORKVIEW
std::cerr << "NetworkView: Adding Edge: ";
std::cerr << *sit << " <-> " << it->first;
std::cerr << std::endl;
#endif
if(_node_ids.find(*sit) != _node_ids.end())
ui.graphicsView->addEdge(_node_ids[*sit], it->second);
}
}
_should_update = false ;
}
int main() {
if ( init() == 0 ) {
printf("aRobot init success !\n");
} else {
printf("aRobot init failed , and exit\n");
return 0;
}
char raw[25];
int lebal = 0;
fgets(raw, 20, stdin);
raw[strlen(raw)-1]='\0';
while ( raw[0] == '\0' || strstr(AROBOT_EXIT, raw) == NULL) {
lebal = 0;
if (strcmp(raw, AROBOT_ACTION) == 0 ) {
lebal = 1;
action();
}
if (strcmp(raw, STAT_ACTION_SIT) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_SIT;
sit();
}
if (strcmp(raw, STAT_ACTION_SLEEP) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_SLEEP;
sleep();
}
if (strcmp(raw, STAT_ACTION_WALK) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_WALK;
walk();
}
if (strcmp(raw, STAT_ACTION_RUN) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_RUN;
run();
}
if (strncmp(raw, STAT_ACTION_EAT, strlen(STAT_ACTION_EAT)) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_EAT;
eat(raw+strlen(STAT_ACTION_EAT));
}
if (strcmp(raw, STAT_ACTION_HEAR_AND_SAY) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_HEAR_AND_SAY;
char word[255];
dyf->hear(word, 255);
dyf->say(word);
//hearf(word, 255);
//sayf(word);
}
if (strncmp(raw, STAT_ACTION_DRINK, strlen(STAT_ACTION_DRINK)) == 0 ) {
lebal = 1;
actionType = STAT_ACTION_DRINK;
drink(raw + strlen(STAT_ACTION_DRINK) );
}
if ( ! lebal ) {
wrong();
}
fgets(raw, 20, stdin);
raw[strlen(raw)-1]='\0';
}
printf("Bye bye !\n");
if (dlhandler) dlclose(dlhandler);
return 0;
}
std::shared_ptr<STTx const>
deserializeTx (SHAMapItem const& item)
{
SerialIter sit(item.slice());
return std::make_shared<STTx const>(sit);
}
/// Undo moving several objects.
void UndoBuffer::undoMoveMultiple(Undo* u)
{
Project* p;
p = u->getProject();
// QListIterator<GState> i(*u->getSList());
// QList<GTransition>* tl = u->getTList();
// GState* s;
// GTransition* t;
double x, y;
// QList<GObject>* sellist;
Selection* sel;
QList<GState*>* ssellist;
QList<GTransition*>* tsellist;
// bool dragmultiple;
ScrollView* sv;
u->getMovedBy(x, y);
sv = project->getMain()->getScrollView();
sel = sv->getDrawArea()->getSelection();
sel->deselectAll(project->machine);
ssellist = u->getSList2();
tsellist = u->getTList2();
QListIterator<GState*> sit(*ssellist);
for(;sit.hasNext();)
sel->select(sit.next());
QListIterator<GTransition*> tit(*tsellist);
for(;tit.hasNext();)
sel->select(tit.next());
/*
for(; i.current(); ++i)
{
s = i.current();
s->move(-x, -y, project->getMain()->getScrollView(), project->machine, FALSE);
}
*/
// dragmultiple = sv->getDragMultiple();
sel->move(-x, -y, project->getMain()->getScrollView()->getDrawArea(), p->machine);
/*
s = project->machine->getPhantomState();
QListIterator<GTransition> j(s->tlist);
for(; j.current(); ++j)
{
t = j.current();
if (t->getEnd()==NULL && tl->containsRef(t))
t->move(-x, -y);
}
*/
/*
sit.toFirst();
for(;sit.current(); ++sit)
sel->deselect(sit.current());
*/
sel->deselectAll(p->machine);
}
void tGraph::draw(QPainter & paint) {
//QPainter paint(this);
paint.save();
int gx1 = hPadding() + _rect.x();
int gy1 = vPadding() + _rect.y();
int gx2 = _rect.x() + width() - hPadding();
int gy2 = _rect.y() + height() - vPadding();
//paint.drawRect(gx1, gy1, gx2 - gx1, gy2 - gy1);
QFontMetrics fm(font());
//QRect brect;
// get the dimensions of the title label and then draw it
if(title().length() > 0) {
fm = QFontMetrics(titleFont());
//brect = fm.boundingRect(title());
paint.setFont(titleFont());
paint.drawText(gx1, gy1, gx2 - gx1, fm.height(), titleAlignment(), title());
gy1 += fm.height();
}
// we need to do some drawing that depends on some other elements having
// already been placed... since those require that these have already been
// placed we will just save the old value of gy2 and then calculate the
// value that we should have after the other code runs without actually
// drawing anything right now
int gy2_old = gy2;
if(dataLabel().length() > 0) {
fm = QFontMetrics(dataLabelFont());
gy2 -= fm.height();
}
fm = QFontMetrics(dataFont());
double tlh = 0.0;
QMapIterator<int, GReference> dlit(_data);
while(dlit.hasNext())
{
dlit.next();
tlh = QMAX(sin45deg * fm.width(dlit.value().first), tlh);
}
// don't change this variable as we use it later
int th = (tlh == 0.0 ? 0 : (int)(tlh + (fm.height() * sin45deg)) + 2);
gy2 -= th;
// get the dimensions of the value label then draw it
if(valueLabel().length() > 0) {
fm = QFontMetrics(valueLabelFont());
//brect = fm.boundingRect(valueLabel());
paint.setFont(valueLabelFont());
paint.save();
paint.rotate(-90);
paint.drawText(-gy2, gx1, gy2 - gy1, fm.height(), valueLabelAlignment(), valueLabel());
paint.restore();
gx1 += fm.height();
}
fm = QFontMetrics(valueFont());
QString min_str = QString().sprintf("%-.0f",minValue());
QString org_str = ( minValue() == 0.0 ? QString::null : QString("0") );
QString max_str = QString().sprintf("%-.0f",maxValue());
int width = QMAX(fm.width(min_str), fm.width(max_str));
if(org_str.length() > 0) width = QMAX(width, fm.width(org_str));
gx1 += width;
int gy_max = gy1;
int gy_min = gy2 - 1;
int gy_org = gy_min;
paint.setFont(valueFont());
int tfa = Qt::AlignTop | Qt::AlignRight;
paint.drawText(gx1 - fm.width(min_str), gy_min, fm.width(min_str), fm.height(), tfa, min_str);
paint.drawLine(gx1 - 3, gy_min, gx1 + 2, gy_min);
paint.drawText(gx1 - fm.width(max_str), gy_max, fm.width(max_str), fm.height(), tfa, max_str);
paint.drawLine(gx1 - 3, gy_max, gx1 + 2, gy_max);
int gheight = gy2 - gy1;
double grng = maxValue() - minValue();
if(org_str.length() > 0) {
double perc = (0 - minValue()) / grng;
gy_org = gy2 - (int)(perc * (double)gheight);
paint.drawText(gx1 - fm.width(org_str), gy_org, fm.width(org_str), fm.height(), tfa, org_str);
paint.drawLine(gx1 - 3, gy_org, gx1 + 2, gy_org);
}
gx1 += 3;
// put the old value back so all the code to come draw correctly!
gy2 = gy2_old;
// get the dimensions of the data label then draw it
if(dataLabel().length() > 0) {
fm = QFontMetrics(dataLabelFont());
//brect = fm.boundingRect(dataLabel());
paint.setFont(dataLabelFont());
gy2 -= fm.height();
paint.drawText(gx1, gy2, gx2 - gx1, fm.height(), dataLabelAlignment(), dataLabel());
}
gy2 -= th;
int ref_cnt = _data.count();
int gwidth = gx2 - gx1;
gheight = gy2 - gy1;
if(ref_cnt > 0) {
paint.save();
fm = QFontMetrics(dataFont());
paint.setFont(dataFont());
int refwidth = QMAX(1, gwidth / ref_cnt);
int buf = (int)(refwidth / 5);
int buf2 = buf * 2;
int pos = gx1 + (int)((gwidth - (refwidth * ref_cnt)) / 2);
int bar_height;
int fmheight = fm.height();
int fmheight_div_2 = fmheight / 2;
int refwidth_div_2 = refwidth / 2;
int label_offset = (int)(fmheight_div_2 * cos45deg);
int last_label_at = -1000;
QMap<int, double> last_map;
QMap<int, double> this_map;
QMapIterator<int, GReference> rit(_data);
while(rit.hasNext())
{
rit.next();
GReference ref = rit.value();
QString label = ref.first;
if(label.length() > 0 && ((pos + refwidth_div_2) - last_label_at) > ((label_offset * 2) + 1)) {
last_label_at = pos + refwidth_div_2;
int lx = (int)(((pos + refwidth_div_2) * cos45deg) - ((gy2 + label_offset) * sin45deg));
int ly = (int)(((pos + refwidth_div_2) * sin45deg) + ((gy2 + label_offset) * cos45deg));
int fmwidth = fm.width(label);
paint.save();
paint.rotate(-45);
paint.drawText(lx - fmwidth, ly - fmheight_div_2, fmwidth, fmheight, Qt::AlignRight | Qt::AlignTop, label);
paint.restore();
}
QMapIterator<int, double> sit(ref.second);
paint.save();
if(drawBars() == TRUE) {
TSetValue tval;
QMap<double, TSetValue> sort_map;
sit = ref.second;
while(sit.hasNext())
{
sit.next();
if(sit.value() != 0.0 && _setStyle[sit.key()].bar == TRUE) {
tval.first = sit.key();
tval.second = sit.value();
sort_map[(tval.second < 0.0 ? minValue() : maxValue()) - (tval.second < 0.0 ? -tval.second : tval.second)] = tval;
}
}
QMapIterator<double, TSetValue> it(sort_map);
while(it.hasNext())
{
it.next();
tval = it.value();
if(tval.second != 0.0) {
if(tval.second < 0) {
bar_height = (int)((tval.second / minValue()) * (gy_org - gy_min));
} else {
bar_height = (int)((tval.second / maxValue()) * (gy_org - gy_max));
}
paint.fillRect(pos + buf, gy_org - bar_height, refwidth - buf2, bar_height, getSetColor(tval.first));
}
}
}
if(drawLines() == TRUE) {
this_map.clear();
sit = ref.second;
while(sit.hasNext())
{
sit.next();
if(_setStyle[sit.key()].line == TRUE) {
this_map[sit.key()] = sit.value();
if(last_map.contains(sit.key())) {
paint.setPen(getSetColor(sit.key()));
double old_val = last_map[sit.key()];
double new_val = sit.value();
int ly1;
if(old_val < 0.0) ly1 = (int)((old_val / minValue()) * (gy_org - gy_min));
else ly1 = (int)((old_val / maxValue()) * (gy_org - gy_max));
ly1 = gy_org - ly1;
int lx1 = pos - refwidth_div_2;
int ly2;
if(new_val < 0.0) ly2 = (int)((new_val / minValue()) * (gy_org - gy_min));
else ly2 = (int)((new_val / maxValue()) * (gy_org - gy_max));
ly2 = gy_org - ly2;
int lx2 = pos + refwidth_div_2;
paint.drawLine(lx1, ly1, lx2, ly2);
}
}
}
last_map = this_map;
}
if(drawPoints() == TRUE) {
sit = ref.second;
while(sit.hasNext())
{
sit.next();
if(_setStyle[sit.key()].point == TRUE) {
paint.setBrush(getSetColor(sit.key()));
paint.setPen(QColor(0,0,0));
int ly1;
if(sit.value() < 0.0) ly1 = (int)((sit.value() / minValue()) * (gy_org - gy_min));
else ly1 = (int)((sit.value() / maxValue()) * (gy_org - gy_max));
ly1 = gy_org - ly1;
int lx1 = pos + refwidth_div_2;
paint.drawEllipse(lx1 - 2, ly1 - 2, 5, 5);
}
}
}
paint.restore();
pos += refwidth;
}
paint.restore();
}
paint.drawLine(gx1, gy_org, gx2 - 1, gy_org);
paint.drawRect(gx1, gy1, gx2 - gx1, gy2 - gy1);
// Now that we are done return the paint device back to the state
// it was when we started to mess with it
paint.restore();
}