void Process_reference_string(char* reference_string, int npages, int nframes)
{
int page; int *frame = (int*)malloc(sizeof(int));
printf("MV_START: %d pages, %d frames\n\n",npages,nframes);
mv_start(npages, nframes);
int page_faults = 0;
int i = 0;
while(reference_string[i] != '\0')
{
page = reference_string[i] - '0';
int hit = (mv(page,frame) == 0);
if(!hit)
{
page_faults = page_faults + 1;
printf("MISS: requested page: %d was put in frame: %d\n",page,*frame);
}
else
{
printf("HIT: requested page: %d was in frame: %d\n",page,*frame);
}
i++;
}
printf("\nFrames final state:\n");
/*
for(i = 0; i < nframes; i++)
{
if(memory[i] != -1)
printf(" frame %d -> page %d\n",i,memory[i]);
else
printf(" frame %d -> EMPTY\n",i);
}
*/
mv_stop( );
printf("\n-----------------------------------------------------------------\n");
}
void show_winners(struct Board B, int st, bool useMiai) {
int MP[TotalCells]; int MPsize;
printf(" %c next-move winners\n",emit(st));
for (int r=0; r<N; r++) {
for (int k=0; k<r; k++) printf(" ");
for (int c=0; c<N-r; c++) {
int lcn = fatten(r,c);
Move mv(st,lcn);
if ((B.board[lcn]==EMP)&&(is_win(B,mv,useMiai,MP,MPsize,false)))
printf(" * ");
else
printf(" . ");
}
printf("\n");
}
printf("\n");
}
int _mv(int argc, char ** argv) {
if(argc > 2)
{
int code = mv(argv[1], argv[2]);
if(code > 0) {
printf("Moved from %s to %s successfully\n", argv[1], argv[2]);
} else if(code == ERR_PERMS) {
printf("You don't have the permissions to move %s to %s\n", argv[1], argv[2]);
} else if(code == ERR_INVALID_TYPE) {
printf("Can't move: invalid filetype for %s\n", argv[2]);
} else if(code == ERR_REPEATED) {
printf("Can't move: file %s already exists in destination %s\n", argv[1], argv[2]);
} else {
printf("WTF %d uncached error code D:\n", code);
}
}
}
void BilinearTermBase::get(MElement *ele, int npts, IntPt *GP, fullMatrix<double> &m) const
{
std::vector<fullMatrix<double> > mv(npts);
get(ele,npts,GP,mv);
m.resize(mv[0].size1(), mv[0].size2());
m.setAll(0.);
double jac[3][3];
for (int k=0;k<npts;k++)
{
const double u = GP[k].pt[0]; const double v = GP[k].pt[1]; const double w = GP[k].pt[2];
const double weight = GP[k].weight; const double detJ = ele->getJacobian(u, v, w, jac);
const double coeff=weight*detJ;
for (int i=0;i<mv[k].size1();++i)
for (int j=0;j<mv[k].size2();++j)
m(i,j)+=mv[k](i,j)*coeff;
}
}
void* default_unli_parser (void* arg)
{
void* retr = NULL;
std::vector<std::string> list;
std::string pattern = std::string(Config::getLocalProcessedDir()) + std::string("*.csv");
std::vector<default_unli_t> default_unlis;
LOG_INFO("%s: Started.", __func__);
LOG_INFO("%s: processing %s files.", __func__, pattern.c_str());
while (! IS_SHUTDOWN()) {
glob(list, pattern);
//LOG_DEBUG("%s: got %d files.", __func__, list.size());
for (size_t i=0; i<list.size(); ++i) {
std::string &src = list[i];
std::string dest = Config::getLocalCompletedDir() + basename(src);
load_default_unli(default_unlis, src);
LOG_INFO("%s: got %d items from %s.", __func__, default_unlis.size(), src.c_str());
if (0 != mv(src, dest)) {
LOG_ERROR("%s: Unable to move '%s' to '%s'", __func__, src.c_str(), dest.c_str());
continue;
}
for (size_t j=0; j<default_unlis.size(); ++j) {
default_unli_t& default_unli = default_unlis[j];
if (0 != c2q_enqueue(Global::getDefaultUnliQ(), (void*) &default_unli, sizeof(default_unli_t))) {
LOG_ERROR("%s: Unable to insert to default_unli queue: msisdn: %s, mnc: %s, mcc: %s, sgsn_ip: %s, date: %s, filename: %s", __func__
, default_unli.msisdn, default_unli.mnc, default_unli.mcc
, default_unli.sgsn_ip, default_unli.date, default_unli.filename);
}
}
}
//-- sleep for a while
sys_msleep(1000);
}
LOG_INFO("%s: Terminated.", __func__);
return retr;
}
bool PNS_VIA::PushoutForce( PNS_NODE* aNode,
const VECTOR2I& aDirection,
VECTOR2I& aForce,
bool aSolidsOnly,
int aMaxIterations )
{
int iter = 0;
PNS_VIA mv( *this );
VECTOR2I force, totalForce;
while( iter < aMaxIterations )
{
PNS_NODE::OptObstacle obs = aNode->CheckColliding( &mv,
aSolidsOnly ? PNS_ITEM::SOLID : PNS_ITEM::ANY );
if( !obs )
break;
int clearance = aNode->GetClearance( obs->item, &mv );
if( iter > 10 )
{
VECTOR2I l = -aDirection.Resize( m_diameter / 4 );
totalForce += l;
mv.SetPos( mv.GetPos() + l );
}
if( ShPushoutForce( obs->item->GetShape(), mv.GetPos(), mv.GetDiameter() / 2, force,
clearance ) )
{
totalForce += force;
mv.SetPos( mv.GetPos() + force );
}
iter++;
}
if( iter == aMaxIterations )
return false;
aForce = totalForce;
return true;
}
void SupprimerSousTache::suppressionSousTache(){
try{
if (ui->comboBoxSousTache->currentText()!=QString(" ") && ui->comboBoxTacheMere->currentText()!=QString(" ")) {
TacheComposite* mere =static_cast<TacheComposite*>(ProjetManager::getInstance().trouverTache(ui->comboBoxTacheMere->currentText()));
Tache* soustache = ProjetManager::getInstance().trouverTache(ui->comboBoxSousTache->currentText());
mere->removeSousTache(soustache);
MessageValidation mv(QString("Succès"), QString("La sous-tâche "+ui->comboBoxSousTache->currentText()+" a été enlevée à "+ui->comboBoxTacheMere->currentText()+"."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else { remplirComboTacheMere(ui->comboBoxProjet->currentText()); }
}
else
throw CalendarException("Veuillez séléctionner des tâches");
}
catch(CalendarException e){
QMessageBox::warning(this, "Erreur Suppression", e.getInfo());
}
}
void FPSCamera::onUpdate(float elapsed) {
glm::vec3 mv(0,0,0);
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
mv += m_forward*elapsed*m_moveSpeed;
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
mv -= m_forward*elapsed*m_moveSpeed;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
mv += m_left*elapsed*m_moveSpeed;
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
mv -= m_left*elapsed*m_moveSpeed;
auto mz = m_window.getMouse().getMouseDelta();
//float wheel = m_window.getMouse().getWheelDelta();
//zoom(wheel*elapsed*5.f);
rotate(mz.x*elapsed, mz.y*elapsed);
move(mv);
}
int main()
{
std::vector< std::vector<int> > mh(M, std::vector<int>(N-1));
std::vector< std::vector<int> > mv(M-1, std::vector<int>(N));
std::vector< std::vector<int> > visited(M, std::vector<int>(N));
initialize(visited, mh, mv);
srand (time(NULL));
//empiezo en una posicion random
int posx = rand() % N;
int posy = rand() % M;
crear(posx, posy, visited, mh, mv);
printMaze(mh,mv);
return 0;
}
void DeprogActivite::EnregistrerDeprogActivite(){
const Programmation* activite=ProgrammationManager::getInstance().trouverEvenement(ui->comboBoxActivite->currentText());
if (activite!=0){
try{
ProgrammationManager::getInstance().deprogrammationEvenement(activite->getDateTime());
MessageValidation mv(QString("Succès"), QString("L'activité a été déprogrammée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else {
ui->labelProgrammation->clear();
remplirComboBoxActivite();
}
}
catch(CalendarException e){ QMessageBox::warning(this, "Erreur", e.getInfo()); }
}
else
QMessageBox::information(this, "Attention", "Veuillez selectionner une activite");
}
int runCommand(){
int i = 0;
int argc = splitString(textBuffer, ' ');
for(i =0;i<argc;i++){argv[i]=stringArray[i];}
if(k_strcmp(argv[0], "")==0){}
else if(k_strcmp(argv[0], "clear")==0){ clearScreen(); typeOffset = 0;}
else if(k_strcmp(argv[0], "history")==0){ printHistory();}
else if(k_strcmp(argv[0], "pong")==0){ pong();}
else if(k_strcmp(argv[0], "help")==0){ listCommands();}
else if(k_strcmp(argv[0], "welcome")==0){ welcome();}
else if(k_strcmp(argv[0], "splash")==0){ splash();}
else if(k_strcmp(argv[0], "ls")==0){ ls(argc, argv); }
else if(k_strcmp(argv[0], "cat")==0){ cat(argc, argv); }
else if(k_strcmp(argv[0], "rm")==0){ rm(argc, argv); }
else if(k_strcmp(argv[0], "chmod")==0){ chmod(argc, argv); }
else if(k_strcmp(argv[0], "te")==0){ te(argc, argv); }
else if(k_strcmp(argv[0], "cp")==0){ cp(argc, argv); }
else if(k_strcmp(argv[0], "diff")==0){ diff(argc, argv); }
else if(k_strcmp(argv[0], "wc")==0){ wc(argc, argv); }
else if(k_strcmp(argv[0], "su")==0){ su(argc, argv); }
else if(k_strcmp(argv[0], "chown")==0){ chown(argc, argv); }
else if(k_strcmp(argv[0], "echo")==0){ echo(argc, argv); }
else if(k_strcmp(argv[0], "adduser")==0){ adduser(argc, argv); }
else if(k_strcmp(argv[0], "deluser")==0){ deluser(argc, argv); }
else if(k_strcmp(argv[0], "listus")==0){ listus(); }
else if(k_strcmp(argv[0], "passwd")==0){ passwd(argc, argv); }
else if(k_strcmp(argv[0], "mkdir")==0){ mkdir(argc, argv); }
else if(k_strcmp(argv[0], "rmdir")==0){ rmdir(argc, argv); }
else if(k_strcmp(argv[0], "cd")==0){ cd(argc, argv); }
else if(k_strcmp(argv[0], "pwd")==0){ pwd(argc, argv); }
else if(k_strcmp(argv[0], "mv")==0){ mv(argc, argv); }
// else check files
else {
printToConsole("Error: Unknown command '");
printToConsole(argv[0]);
printToConsole("'\n");
}
return 0;
}
void SuppressionTache::supprimerTache(){
try{
if (ui->comboBoxTache->currentText()!=QString(" ")) {
Projet* projet=ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText());
Tache* tache = projet->trouverTache(ui->comboBoxTache->currentText());
projet->removeTache(tache);
MessageValidation mv(QString("Succès"), QString("La tâche "+ui->comboBoxTache->currentText()+" a été supprimée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else { remplirComboTache(ui->comboBoxProjet->currentText()); }
}
else
throw CalendarException("Veuillez séléctionner une tâche");
}
catch(CalendarException e){
QMessageBox::warning(this, "Erreur Suppression", e.getInfo());
}
}
void SuppressionPrecedence::supprimerPrec() {
try {
QString t=ui->comboBoxTache->currentText();
QString p=ui->listPrecedence->currentItem()->text();
Tache* tache=ProjetManager::getInstance().trouverTache(t);
Tache* pred=ProjetManager::getInstance().trouverTache(p);
if (tache!=0 && pred!=0) {
tache->removePrecedence(pred);
pred->removeSuivant(tache);
MessageValidation mv(QString("Succès"), QString(p+" ne précède plus "+t+"."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else { showPrecedence(t); }
}
else
throw CalendarException("Veuillez sélectionner des tâches.");
}
catch(CalendarException e){QMessageBox::warning(this, "Erreur", e.getInfo());}
}
template <typename M> void MatchT<M>::Part::recalculateBox(const xform& _alignMtx)
{
typename ShapeT<M>::Mesh & cMesh = partShape_.mesh();
typename TriangleMesh::ConstVertexIter vIt(cMesh.vertices_begin()), vEnd(cMesh.vertices_end());
typename ShapeT<M>::BBox cBBox;
for (; vIt!= vEnd; ++vIt)
{
OpenMesh::Vec3f p_i = mv(_alignMtx, cMesh.point(vIt));
cBBox.min.minimize(p_i);
cBBox.max.maximize(p_i);
}
scale_ = (cBBox.max - cBBox.min) * 0.5f;
pos_ = cBBox.min + scale_;
}
//------------------------------------------------------------------------------
int main(int, char**) {
try {
Movable mvbl(MovableFactory(555));
std::vector< Movable > movables;
Movable mv(new int(2));
Movable mv2;
mv2 = mv;
movables.push_back(mv2);
assert(movables[0].data() == 2);
}catch(const std::exception& e) {std::cout << e.what() << std::endl;}
std::cout << "Resource destructions: " << Movable::dbg_destructors
<< " Copies: " << Movable::dbg_copies
<< " Instances created: " << Movable::dbg_instances << std::endl;
// PointerHandler<int>::type pi(new int(2));
// assert(*pi.res() == 2);
// PointerHandler<int>::type pi2((pi));
// assert(pi.res() == 0);
// assert(*pi2.res() == 2);
// IH pi3 = foo();
// pi3 = foo();
// bar(move(IH(new int(5))));
// std::vector< IH > phandlers(2);
// // phandlers.push_back(move(pi2));
// // assert(*phandlers.back().res() == 2);
// phandlers[0] = pi2;
// phandlers.push_back(move(IH(new int(123))));
// assert(*phandlers.back().res() == 123);
// #ifndef WRAP_RESOURCE
// assert(phandlers[0].moves() == 4);
// PointerHandler<int>::type pi4(move(phandlers[0]));
// assert(*pi4.res() == 2);
// assert(pi2.res() == 0);
// assert(pi4.moves() == 5);
// assert(pi3.moves() == 2);
// // foo -> temporary: 1 move
// // temporary -> proxy
// // proxy -> pre-existing instance = operator: +1 move
// #endif
return 0;
}
void ProgTache::EnregistrerProgTache(){
if(ProjetManager::getInstance().isTacheExistante(ui->comboBoxTache->currentText())){
TacheUnitaire* t = dynamic_cast<TacheUnitaire*>(ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText())->trouverTache(ui->comboBoxTache->currentText()));
Duree d = Duree(ui->timeEdit_2->time().hour(),ui->timeEdit_2->time().minute());
try {
ProgrammationManager::getInstance().ajouterProgrammationTache(t, ui->dateTimeEdit_2->dateTime(), d);
MessageValidation mv(QString("Succès"), QString("La programmation a été ajoutée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else {
//Si l'utilisateur veut programmer une nouvelle tâche
remplirComboTache(ui->comboBoxProjet->currentText()); //On actualise les tâches disponibles à la programamtion
ui->timeEdit_2->setTime(QTime(0,0)); //On réinitialise la durée de programmation
SetInfos(QString(" ")); //On enlève les infos de la tâche précédemment programmée
}
}
catch(CalendarException e){ QMessageBox::warning(this, "Erreur", e.getInfo()); }
}
else
QMessageBox::warning(this, "Programmation", "Veuillez séléctionner une tâche");
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Q_UNUSED(a)
if (argc >= 3 && !qstrcmp(argv[1], "ls"))
return ls(argc -2, argv + 2);
if (argc == 4 && !qstrcmp(argv[1], "mv"))
return mv(argv[2], argv[3]);
if (argc == 4 && !qstrcmp(argv[1], "cp"))
return cp(argv[2], argv[3]);
if (argc == 3 && !qstrcmp(argv[1], "rm"))
return rm(argv[2]);
if (argc == 3 && !qstrcmp(argv[1], "rmr"))
return rmr(argv[2]);
std::cerr << usage1 << argv[0] << usage2;
return 0;
}
bool ChIntegrableIIorder::StateSolve(ChStateDelta& dydt, // result: computed dydt
ChVectorDynamic<>& L, // result: computed lagrangian multipliers, if any
const ChState& y, // current state y
const double T, // current time T
const double dt, // timestep (if needed, ex. in NSC)
bool force_state_scatter // if false, y and T are not scattered to the system
) {
ChState mx(GetNcoords_x(), y.GetIntegrable());
ChStateDelta mv(GetNcoords_v(), y.GetIntegrable());
mx.PasteClippedMatrix(y, 0, 0, GetNcoords_x(), 1, 0, 0);
mv.PasteClippedMatrix(y, GetNcoords_x(), 0, GetNcoords_v(), 1, 0, 0);
ChStateDelta ma(GetNcoords_v(), y.GetIntegrable());
// Solve with custom II order solver
if (!StateSolveA(ma, L, mx, mv, T, dt, force_state_scatter)) {
return false;
}
dydt.PasteMatrix(mv, 0, 0);
dydt.PasteMatrix(ma, GetNcoords_v(), 0);
return true;
}
void ProgActivite::EnregistrerProg(){
if((ui->lineEditType->text()!=NULL) && (ui->lineEditDescription->text()!=NULL) && (ui->lineEditLieu->text()!=NULL) && (ui->lineEditNom->text()!=NULL)){
Duree d = Duree(ui->timeEdit->time().hour(),ui->timeEdit->time().minute());
try{
ProgrammationManager::getInstance().ajouterProgrammationEvenement(ui->lineEditNom->text(), ui->lineEditType->text(), ui->lineEditDescription->text(), ui->lineEditLieu->text(), ui->dateTimeEdit->dateTime(), d);
MessageValidation mv(QString("Succès"), QString("L'activité a été ajoutée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else {
//Si l'utilisateur veut ajouter une nouvelle activité, on réinitialise tous les champs
ui->lineEditNom->clear();
ui->lineEditType->clear();
ui->lineEditDescription->clear();
ui->lineEditLieu->clear();
ui->dateTimeEdit->setDateTime(QDateTime::currentDateTime());
ui->timeEdit->setTime(QTime(0, 0));}
}
catch(CalendarException e){ QMessageBox::warning(this, "Erreur", e.getInfo()); }
}
else
QMessageBox::information(this, "Attention", "Veuillez remplir tous les champs");
}
/**
* \brief set mosaic type
*
* This method ensures that the metadata map and the mosaic type
* are consistent.
*/
void ImageBase::setMosaicType(MosaicType::mosaic_type _mosaic) {
mosaic.setMosaicType(_mosaic);
// remove the key
ImageMetadata::iterator i = metadata.find(mosaic_key);
if (i != metadata.end()) {
metadata.erase(i);
}
// compute the new key value
std::string value;
switch (_mosaic) {
case MosaicType::BAYER_RGGB:
value = "RGGB";
break;
case MosaicType::BAYER_GRBG:
value = "GRBG";
break;
case MosaicType::BAYER_GBRG:
value = "GBRG";
break;
case MosaicType::BAYER_BGGR:
value = "BGGR";
break;
default:
// don't store NONE or any other unknown types
break;
}
// if the new value is nonzero, add it
if (value.size() > 0) {
Metavalue mv("BAYER", value, std::string("Bayer Color Matrix"));
std::pair<std::string, Metavalue> p(mosaic_key, mv);
metadata.insert(metadata.begin(), p);
}
}
Z H1(rdc){I r,d[9];ND1 r=a->r-1;Q(r<1,7);R mv(d,a->d+1,r),*d*=*a->d,rsh(a,r,d);}
bool sbbs_t::pack_rep(uint hubnum)
{
char str[MAX_PATH+1];
char tmp[MAX_PATH+1],tmp2[MAX_PATH+1];
char hubid_upper[LEN_QWKID+1];
char hubid_lower[LEN_QWKID+1];
int file,mode;
uint i,j,k;
long msgcnt,submsgs,packedmail,netfiles=0,deleted;
uint32_t u;
uint32_t posts;
uint32_t mailmsgs;
ulong msgs;
uint32_t last;
post_t* post;
mail_t* mail;
FILE* rep;
FILE* hdrs=NULL;
DIR* dir;
DIRENT* dirent;
smbmsg_t msg;
msgcnt=0L;
delfiles(cfg.temp_dir,ALLFILES);
SAFECOPY(hubid_upper,cfg.qhub[hubnum]->id);
strupr(hubid_upper);
SAFECOPY(hubid_lower,cfg.qhub[hubnum]->id);
strlwr(hubid_lower);
SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper);
if(fexistcase(str)) {
eprintf(LOG_INFO,"Updating %s", str);
external(cmdstr(cfg.qhub[hubnum]->unpack,str,ALLFILES,NULL),EX_OFFLINE);
} else
eprintf(LOG_INFO,"Creating %s", str);
/*************************************************/
/* Create SYSID.MSG, write header and leave open */
/*************************************************/
SAFEPRINTF2(str,"%s%s.MSG",cfg.temp_dir,hubid_upper);
fexistcase(str);
if((rep=fnopen(&file,str,O_CREAT|O_WRONLY|O_TRUNC))==NULL) {
errormsg(WHERE,ERR_CREATE,str,O_CREAT|O_WRONLY|O_TRUNC);
return(false);
}
if(filelength(file)<1) { /* New REP packet */
SAFEPRINTF2(str,"%-*s"
,QWK_BLOCK_LEN,hubid_upper); /* So write header */
fwrite(str,QWK_BLOCK_LEN,1,rep);
}
fseek(rep,0L,SEEK_END);
/* Always includes HEADERS.DAT in .REP packets which are only for QWKnet hubs */
/* And *usually* a Synchronet system */
SAFEPRINTF(str,"%sHEADERS.DAT",cfg.temp_dir);
fexistcase(str);
if((hdrs=fopen(str,"a"))==NULL)
errormsg(WHERE,ERR_CREATE,str,0);
/*********************/
/* Pack new messages */
/*********************/
SAFEPRINTF(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
fclose(rep);
if(hdrs!=NULL)
fclose(hdrs);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
/***********************/
/* Pack E-mail, if any */
/***********************/
qwkmail_last=0;
mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0);
packedmail=0;
if(mailmsgs) {
eprintf(LOG_INFO,"Packing NetMail for %s", cfg.qhub[hubnum]->id);
for(u=0;u<mailmsgs;u++) {
// bprintf("\b\b\b\b\b%-5lu",u+1);
memset(&msg,0,sizeof(msg));
msg.idx=mail[u];
if(msg.idx.number>qwkmail_last)
qwkmail_last=msg.idx.number;
if(!loadmsg(&msg,mail[u].number))
continue;
SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id);
if(msg.to_net.type!=NET_QWK
|| (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id)
&& strncmp((char *)msg.to_net.addr,str,strlen(str)))) {
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
continue;
}
msgtoqwk(&msg,rep,QM_TO_QNET|QM_REP|A_LEAVE,INVALID_SUB,0,hdrs);
packedmail++;
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
YIELD(); /* yield */
}
eprintf(LOG_INFO,"Packed %d NetMail messages",packedmail);
}
smb_close(&smb); /* Close the e-mail */
if(mailmsgs)
free(mail);
for(i=0;i<cfg.qhub[hubnum]->subs;i++) {
j=cfg.qhub[hubnum]->sub[i]; /* j now equals the real sub num */
msgs=getlastmsg(j,&last,0);
lncntr=0; /* defeat pause */
if(!msgs || last<=subscan[j].ptr) {
if(subscan[j].ptr>last) {
subscan[j].ptr=last;
subscan[j].last=last;
}
eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp)
,cfg.grp[cfg.sub[j]->grp]->sname
,cfg.sub[j]->lname,0L,msgs);
continue;
}
SAFEPRINTF2(smb.file,"%s%s"
,cfg.sub[j]->data_dir,cfg.sub[j]->code);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=j;
if((k=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
continue;
}
post=loadposts(&posts,j,subscan[j].ptr,LP_BYSELF|LP_OTHERS|LP_PRIVATE|LP_REP,NULL);
eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp)
,cfg.grp[cfg.sub[j]->grp]->sname
,cfg.sub[j]->lname,posts,msgs);
if(!posts) { /* no new messages */
smb_close(&smb);
continue;
}
subscan[j].ptr=last; /* set pointer */
eprintf(LOG_INFO,"%s",remove_ctrl_a(text[QWKPackingSubboard],tmp)); /* ptr to last msg */
submsgs=0;
for(u=0;u<posts;u++) {
// bprintf("\b\b\b\b\b%-5lu",u+1);
memset(&msg,0,sizeof(msg));
msg.idx=post[u];
if(!loadmsg(&msg,post[u].number))
continue;
if(msg.from_net.type && msg.from_net.type!=NET_QWK &&
!(cfg.sub[j]->misc&SUB_GATE)) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
if(!strnicmp(msg.subj,"NE:",3) || (msg.from_net.type==NET_QWK &&
route_circ((char *)msg.from_net.addr,cfg.qhub[hubnum]->id))) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
mode=cfg.qhub[hubnum]->mode[i]|QM_TO_QNET|QM_REP;
if(mode&A_LEAVE) mode|=(QM_VIA|QM_TZ|QM_MSGID);
if(msg.from_net.type!=NET_QWK)
mode|=QM_TAGLINE;
msgtoqwk(&msg,rep,mode,j,cfg.qhub[hubnum]->conf[i],hdrs);
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
msgcnt++;
submsgs++;
if(!(u%50))
YIELD(); /* yield */
}
eprintf(LOG_INFO,remove_ctrl_a(text[QWKPackedSubboard],tmp),submsgs,msgcnt);
free(post);
smb_close(&smb);
YIELD(); /* yield */
}
if(hdrs!=NULL)
fclose(hdrs);
fclose(rep); /* close HUB_ID.MSG */
CRLF;
/* Look for extra files to send out */
SAFEPRINTF2(str,"%sqnet/%s.out",cfg.data_dir,hubid_lower);
dir=opendir(str);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
SAFEPRINTF3(str,"%sqnet/%s.out/%s",cfg.data_dir,hubid_lower,dirent->d_name);
if(isdir(str))
continue;
SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,dirent->d_name);
eprintf(LOG_INFO,remove_ctrl_a(text[RetrievingFile],tmp),str);
if(!mv(str,tmp2,/* copy: */TRUE))
netfiles++;
}
if(dir!=NULL)
closedir(dir);
if(netfiles)
CRLF;
if(!msgcnt && !netfiles && !packedmail) {
eprintf(LOG_INFO,remove_ctrl_a(text[QWKNoNewMessages],tmp));
return(true); // Changed from false Mar-11-2005 (needs to be true to save updated ptrs)
}
/*******************/
/* Compress Packet */
/*******************/
SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper);
SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,ALLFILES);
i=external(cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL)
,EX_OFFLINE|EX_WILDCARD);
if(!fexistcase(str)) {
eprintf(LOG_WARNING,"%s",remove_ctrl_a(text[QWKCompressionFailed],tmp));
if(i)
errormsg(WHERE,ERR_EXEC,cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL),i);
else
lprintf(LOG_ERR, "Couldn't compress REP packet");
return(false);
}
SAFEPRINTF2(str,"%sqnet/%s.out/",cfg.data_dir,hubid_lower);
delfiles(str,ALLFILES);
if(packedmail) { /* Delete NetMail */
SAFEPRINTF(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(true);
}
mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0);
if((i=smb_locksmbhdr(&smb))!=0) { /* Lock the base, so nobody */
if(mailmsgs)
free(mail);
smb_close(&smb);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error); /* messes with the index */
return(true);
}
if((i=smb_getstatus(&smb))!=0) {
if(mailmsgs)
free(mail);
smb_close(&smb);
errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error);
return(true);
}
deleted=0;
/* Mark as READ and DELETE */
for(u=0;u<mailmsgs;u++) {
if(mail[u].number>qwkmail_last)
continue;
memset(&msg,0,sizeof(msg));
/* !IMPORTANT: search by number (do not initialize msg.idx.offset) */
if(!loadmsg(&msg,mail[u].number))
continue;
SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id);
if(msg.to_net.type!=NET_QWK
|| (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id)
&& strncmp((char *)msg.to_net.addr,str,strlen(str)))) {
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
continue;
}
msg.hdr.attr|=MSG_DELETE;
msg.idx.attr=msg.hdr.attr;
if((i=smb_putmsg(&smb,&msg))!=0)
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
else
deleted++;
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
}
if(deleted && cfg.sys_misc&SM_DELEMAIL)
delmail(0,MAIL_YOUR);
smb_close(&smb);
if(mailmsgs)
free(mail);
eprintf(LOG_INFO,"Deleted %d sent NetMail messages",deleted);
}
return(true);
}
void* default_unli_fetcher (void* arg)
{
void* retr = NULL;
std::vector<std::string> list;
std::string pattern = std::string(Config::getLocalDir()) + std::string("/*Gi*.csv");
default_unli_t default_unli;
if (OraDBDefaultUnli::init_lib() < 0) {
LOG_CRITICAL("%s: Unable to initialize libsqlora8!", __func__);
DO_ABORT();
return retr;
}
OraDBDefaultUnli conn;
if (conn.initialize(Config::getOraAuth()) < 0) {
LOG_CRITICAL("%s: Unable to connect to db (%s).", __func__, Config::getOraAuth());
DO_ABORT();
return retr;
}
LOG_INFO("%s: Started.", __func__);
LOG_INFO("%s: processing %s files.", __func__, pattern.c_str());
while (! IS_SHUTDOWN()) {
glob(list, pattern);
//LOG_DEBUG("%s: got %d files.", __func__, list.size());
for (size_t i=0; i < list.size(); ++i) {
std::string &src = list[i];
std::string filename = basename(src);
//-- check if already processed...
memset(&default_unli, 0, sizeof(default_unli_t));
snprintf(default_unli.filename, sizeof(default_unli.filename), "%s", filename.c_str());
if (conn.getLastFileProcessed(&default_unli) < 0) {
LOG_ERROR("%s: Unable to get last default_unli file: retr: %d, filename: %s", __func__
, default_unli.db_retr, default_unli.filename);
} else {
int status = default_unli.db_retr;
if (1 != status) {
LOG_DEBUG("%s: Ignoring previously processed file: %s", __func__, default_unli.filename);
}
std::string processed = Config::getLocalProcessedDir() + filename;
std::string ignored = Config::getLocalIgnoredDir() + filename;
std::string &dest = (1 == status) ? processed : ignored;
if (0 != mv(src, dest)) {
LOG_ERROR("%s: Unable to move '%s' to '%s'", __func__, src.c_str(), dest.c_str());
}
}
}
//-- sleep for a while
sys_msleep(1000);
}
LOG_INFO("%s: Terminated.", __func__);
conn.destroy_db();
return retr;
}
/* FIXME: B-type MBs not handled yet properly */
void x264_visualize_show( x264_t *h )
{
int mb_xy;
static const stringlist_t mb_types[] = {
/* Block types marked as NULL will not be drawn */
{ I_4x4 , "red" },
{ I_8x8 , "#ff5640" },
{ I_16x16 , "#ff8060" },
{ I_PCM , "violet" },
{ P_L0 , "SlateBlue" },
{ P_8x8 , "blue" },
{ P_SKIP , "green" },
{ B_DIRECT, "yellow" },
{ B_L0_L0 , "yellow" },
{ B_L0_L1 , "yellow" },
{ B_L0_BI , "yellow" },
{ B_L1_L0 , "yellow" },
{ B_L1_L1 , "yellow" },
{ B_L1_BI , "yellow" },
{ B_BI_L0 , "yellow" },
{ B_BI_L1 , "yellow" },
{ B_BI_BI , "yellow" },
{ B_8x8 , "yellow" },
{ B_SKIP , "yellow" },
};
static const int waitkey = 1; /* Wait for enter after each frame */
static const int drawbox = 1; /* Draw box around each block */
static const int borders = 0; /* Display extrapolated borders outside frame */
static const int zoom = 2; /* Zoom factor */
static const int pad = 32;
uint8_t *const frame = h->fdec->plane[0];
const int width = h->param.i_width;
const int height = h->param.i_height;
const int stride = h->fdec->i_stride[0];
if (borders) {
disp_gray_zoom(0, frame - pad*stride - pad, width+2*pad, height+2*pad, stride, "fdec", zoom);
} else {
disp_gray_zoom(0, frame, width, height, stride, "fdec", zoom);
}
for( mb_xy = 0; mb_xy < h->sps->i_mb_width * h->sps->i_mb_height; mb_xy++ )
{
visualize_t *const v = (visualize_t*)h->visualize + mb_xy;
const int mb_y = mb_xy / h->sps->i_mb_width;
const int mb_x = mb_xy % h->sps->i_mb_width;
char *const col = GET_STRING(mb_types, v->i_type);
int x = mb_x*16*zoom;
int y = mb_y*16*zoom;
int l = 0;
unsigned int i, j;
if (col==NULL) continue;
if (borders) {
x += pad*zoom;
y += pad*zoom;
}
disp_setcolor(col);
if (drawbox) disp_rect(0, x, y, x+16*zoom-1, y+16*zoom-1);
if (v->i_type==P_L0 || v->i_type==P_8x8 || v->i_type==P_SKIP) {
/* Predicted (inter) mode, with motion vector */
if (v->i_partition==D_16x16 || v->i_type==P_SKIP) {
mv(x+8*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
}
if (v->i_partition==D_16x8) {
if (drawbox) disp_rect(0, x, y, x+16*zoom, y+8*zoom);
mv(x+8*zoom, y+4*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
if (drawbox) disp_rect(0, x, y+8*zoom, x+16*zoom, y+16*zoom);
mv(x+8*zoom, y+12*zoom, v->mv[l][2][0], v->ref[l][2][0], zoom, col);
}
if (v->i_partition==D_8x16) {
if (drawbox) disp_rect(0, x, y, x+8*zoom, y+16*zoom);
mv(x+4*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
if (drawbox) disp_rect(0, x+8*zoom, y, x+16*zoom, y+16*zoom);
mv(x+12*zoom, y+8*zoom, v->mv[l][0][2], v->ref[l][0][2], zoom, col);
}
if (v->i_partition==D_8x8) {
for (i=0; i<2; i++) for (j=0; j<2; j++) {
int sp = v->i_sub_partition[i*2+j];
const int x0 = x + j*8*zoom;
const int y0 = y + i*8*zoom;
l = x264_mb_partition_listX_table[0][sp] ? 0 : 1; /* FIXME: not tested if this works */
if (IS_SUB8x8(sp)) {
if (drawbox) disp_rect(0, x0, y0, x0+8*zoom, y0+8*zoom);
mv(x0+4*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
}
if (IS_SUB8x4(sp)) {
if (drawbox) disp_rect(0, x0, y0, x0+8*zoom, y0+4*zoom);
if (drawbox) disp_rect(0, x0, y0+4*zoom, x0+8*zoom, y0+8*zoom);
mv(x0+4*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
mv(x0+4*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col);
}
if (IS_SUB4x8(sp)) {
if (drawbox) disp_rect(0, x0, y0, x0+4*zoom, y0+8*zoom);
if (drawbox) disp_rect(0, x0+4*zoom, y0, x0+8*zoom, y0+8*zoom);
mv(x0+2*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
mv(x0+6*zoom, y0+4*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col);
}
if (IS_SUB4x4(sp)) {
if (drawbox) disp_rect(0, x0, y0, x0+4*zoom, y0+4*zoom);
if (drawbox) disp_rect(0, x0+4*zoom, y0, x0+8*zoom, y0+4*zoom);
if (drawbox) disp_rect(0, x0, y0+4*zoom, x0+4*zoom, y0+8*zoom);
if (drawbox) disp_rect(0, x0+4*zoom, y0+4*zoom, x0+8*zoom, y0+8*zoom);
mv(x0+2*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
mv(x0+6*zoom, y0+2*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col);
mv(x0+2*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col);
mv(x0+6*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j+1], v->ref[l][2*i+1][2*j+1], zoom, col);
}
}
}
}
if (IS_INTRA(v->i_type) || v->i_type==I_PCM) {
/* Intra coded */
if (v->i_type==I_16x16) {
switch (v->i_intra16x16_pred_mode) {
case I_PRED_16x16_V:
disp_line(0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom);
break;
case I_PRED_16x16_H:
disp_line(0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom);
break;
case I_PRED_16x16_DC:
case I_PRED_16x16_DC_LEFT:
case I_PRED_16x16_DC_TOP:
case I_PRED_16x16_DC_128:
disp_line(0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom);
disp_line(0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom);
break;
case I_PRED_16x16_P:
disp_line(0, x+2*zoom, y+2*zoom, x+8*zoom, y+8*zoom);
break;
}
}
if (v->i_type==I_4x4 || v->i_type==I_8x8) {
const int di = v->i_type==I_8x8 ? 2 : 1;
const int zoom2 = zoom * di;
for (i=0; i<4; i+=di) for (j=0; j<4; j+=di) {
const int x0 = x + j*4*zoom;
const int y0 = y + i*4*zoom;
if (drawbox) disp_rect(0, x0, y0, x0+4*zoom2, y0+4*zoom2);
switch (v->intra4x4_pred_mode[i][j]) {
case I_PRED_4x4_V: /* Vertical */
disp_line(0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2);
break;
case I_PRED_4x4_H: /* Horizontal */
disp_line(0, x0+1*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2);
break;
case I_PRED_4x4_DC: /* DC, average from top and left sides */
case I_PRED_4x4_DC_LEFT:
case I_PRED_4x4_DC_TOP:
case I_PRED_4x4_DC_128:
disp_line(0, x0+1*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2);
disp_line(0, x0+1*zoom2, y0+1*zoom2, x0+1*zoom2, y0+4*zoom2);
break;
case I_PRED_4x4_DDL: /* Topright-bottomleft */
disp_line(0, x0+0*zoom2, y0+0*zoom2, x0+4*zoom2, y0+4*zoom2);
break;
case I_PRED_4x4_DDR: /* Topleft-bottomright */
disp_line(0, x0+0*zoom2, y0+4*zoom2, x0+4*zoom2, y0+0*zoom2);
break;
case I_PRED_4x4_VR: /* Mix of topleft-bottomright and vertical */
disp_line(0, x0+0*zoom2, y0+2*zoom2, x0+4*zoom2, y0+1*zoom2);
break;
case I_PRED_4x4_HD: /* Mix of topleft-bottomright and horizontal */
disp_line(0, x0+2*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2);
break;
case I_PRED_4x4_VL: /* Mix of topright-bottomleft and vertical */
disp_line(0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+2*zoom2);
break;
case I_PRED_4x4_HU: /* Mix of topright-bottomleft and horizontal */
disp_line(0, x0+1*zoom2, y0+0*zoom2, x0+2*zoom2, y0+4*zoom2);
break;
}
}
}
}
}
disp_sync();
if (waitkey) getchar();
}
void EditeurTache::enregisterTache(){
if(!(ProjetManager::getInstance().isProjetExistant(ui->comboBoxProjet->currentText()))){
QMessageBox::warning(this, "Attention", "Veuilliez choisir un projet.");
}
else{
QString id = ui->lineEditId->text();
QString titre = ui->lineEditTitre->text();
if((id==NULL) || (titre==NULL))
QMessageBox::warning(this, "Attention", "Veuilliez donnez un identificateur et un titre.");
else{
QDate disp = ui->dateEditDispo->date();
QDate ech = ui->dateEditEch->date();
if(ui->radioButtonUnit->isChecked()){
Duree d = Duree(ui->timeEditDuree->time().hour(),ui->timeEditDuree->time().minute());
bool pre = ui->radioButtonOui->isChecked();
if((d.getDureeEnMinutes()==0)|| (pre==false && ui->radioButtonNon->isChecked()==false))//test si les champs durée et preemptive sont bien renseignés
QMessageBox::warning(this, "Attention", "Veuilliez renseigner la durée de la tache.");
else{
try{
TacheUnitaire& t = (ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText())->ajouterTacheUnitaire(id,titre, disp,ech, d, pre));
//ajouter précédence
try {
for(QMap<QString, Tache*>::const_iterator it= predecesseurs.cbegin();it!=predecesseurs.cend();it++){
t.ajouterPrecedence(*(*it));
}
//ajouter tache mère
if(ui->comboBoxMere->currentText()!=QString(" ")) {
static_cast<TacheComposite*>(ProjetManager::getInstance().trouverTache(ui->comboBoxMere->currentText()))->ajouterSousTache(t);
}
//emit nouvelleTache();
MessageValidation mv(QString("Succès"), QString("La tache "+ui->lineEditId->text()+" a été ajoutée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else { ui->lineEditId->clear(); ui->lineEditTitre->clear(); remplirComboMere(ui->comboBoxProjet->currentText()); }
}
catch(CalendarException e){
QMessageBox::warning(this, "Erreur", e.getInfo());
ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText())->removeTache(&t);
}
}
catch(CalendarException e){
QMessageBox::warning(this, "Erreur", e.getInfo());
}
}
}
else if(ui->radioButtonComp->isChecked()){
try{
TacheComposite& t = (ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText())->ajouterTacheComposite(id, titre, disp, ech));
//ajouter précédence
try {
for(QMap<QString, Tache*>::const_iterator it= predecesseurs.cbegin();it!=predecesseurs.cend();it++){
t.ajouterPrecedence(*(*it));
}
//ajouter tache mère
if(ui->comboBoxMere->currentText()!=QString(" ")) {
static_cast<TacheComposite*>(ProjetManager::getInstance().trouverTache(ui->comboBoxMere->currentText()))->ajouterSousTache(t);
}
MessageValidation mv(QString("Succès"), QString("La tache "+ui->lineEditId->text()+" a été ajoutée."));
int rep = mv.exec();
if (rep == QMessageBox::No)
close();
else { ui->lineEditId->clear(); ui->lineEditTitre->clear(); remplirComboMere(ui->comboBoxProjet->currentText()); }
}
catch(CalendarException e){
QMessageBox::warning(this, "Erreur", e.getInfo());
ProjetManager::getInstance().trouverProjet(ui->comboBoxProjet->currentText())->removeTache(&t);
}
//ajouter sous taches*/
}
catch(CalendarException e){QMessageBox::warning(this, "Erreur", e.getInfo());}
}
else
QMessageBox::warning(this, "Attention", "Veuillez renseigner le champ 'type de tache'");
}
}
}
Z H1(sha){A z;ND1 W(gv(It,a->r))mv(z->p,a->d,a->r);R(I)z;}
bool sbbs_t::email(int usernumber, const char *top, const char *subj, long mode)
{
char str[256],str2[256],msgpath[256],title[LEN_TITLE+1],ch
,buf[SDT_BLOCK_LEN];
char tmp[512];
char pid[128];
char* editor=NULL;
ushort msgattr=0;
uint16_t xlat=XLAT_NONE;
ushort nettype;
int i,j,x,file;
long l;
long length;
ulong offset;
uint32_t crc=0xffffffffUL;
FILE* instream;
node_t node;
smbmsg_t msg;
SAFECOPY(title,subj);
if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP && !(useron.exempt&FLAG('M'))) {
bputs(text[TooManyEmailsToday]);
return(false);
}
if(usernumber==1 && useron.rest&FLAG('S')
&& (cfg.node_valuser!=1 || useron.fbacks || useron.emails)) { /* ! val fback */
bprintf(text[R_Feedback],cfg.sys_op);
return(false);
}
if(usernumber!=1 && useron.rest&FLAG('E')
&& (cfg.node_valuser!=usernumber || useron.fbacks || useron.emails)) {
bputs(text[R_Email]);
return(false);
}
if(!usernumber) {
bputs(text[UnknownUser]);
return(false);
}
getuserrec(&cfg,usernumber,U_MISC,8,str);
l=ahtoul(str);
if(l&(DELETED|INACTIVE)) { /* Deleted or Inactive User */
bputs(text[UnknownUser]);
return(false);
}
if((l&NETMAIL) && (cfg.sys_misc&SM_FWDTONET)) {
getuserrec(&cfg,usernumber,U_NETMAIL,LEN_NETMAIL,str);
bprintf(text[UserNetMail],str);
if((mode & WM_FORCEFWD) || text[ForwardMailQ][0]==0 || yesno(text[ForwardMailQ])) /* Forward to netmail address */
return(netmail(str,subj,mode));
}
bprintf(text[Emailing],username(&cfg,usernumber,tmp),usernumber);
action=NODE_SMAL;
nodesync();
sprintf(str,"%sfeedback.*", cfg.exec_dir);
if(usernumber==cfg.node_valuser && useron.fbacks && fexist(str)) {
exec_bin("feedback",&main_csi);
if(main_csi.logic!=LOGIC_TRUE)
return(false);
}
if(cfg.sys_misc&SM_ANON_EM && useron.exempt&FLAG('A')
&& !noyes(text[AnonymousQ]))
msgattr|=MSG_ANONYMOUS;
if(cfg.sys_misc&SM_DELREADM)
msgattr|=MSG_KILLREAD;
msg_tmp_fname(useron.xedit, msgpath, sizeof(msgpath));
username(&cfg,usernumber,str2);
if(!writemsg(msgpath,top,title,mode,INVALID_SUB,str2,&editor)) {
bputs(text[Aborted]);
return(false);
}
if(mode&WM_FILE && !SYSOP && !(cfg.sys_misc&SM_FILE_EM))
mode&=~WM_FILE;
if(mode&WM_FILE) {
sprintf(str2,"%sfile/%04u.in", cfg.data_dir,usernumber);
MKDIR(str2);
sprintf(str2,"%sfile/%04u.in/%s", cfg.data_dir,usernumber,title);
if(fexistcase(str2)) {
bputs(text[FileAlreadyThere]);
remove(msgpath);
return(false);
}
{ /* Remote */
xfer_prot_menu(XFER_UPLOAD);
mnemonics(text[ProtocolOrQuit]);
strcpy(str,"Q");
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && chk_ar(cfg.prot[x]->ar,&useron,&client)) {
sprintf(tmp,"%c",cfg.prot[x]->mnemonic);
strcat(str,tmp);
}
ch=(char)getkeys(str,0);
if(ch=='Q' || sys_status&SS_ABORT) {
bputs(text[Aborted]);
remove(msgpath);
return(false);
}
for(x=0;x<cfg.total_prots;x++)
if(cfg.prot[x]->ulcmd[0] && cfg.prot[x]->mnemonic==ch
&& chk_ar(cfg.prot[x]->ar,&useron,&client))
break;
if(x<cfg.total_prots) /* This should be always */
protocol(cfg.prot[x],XFER_UPLOAD,str2,nulstr,true);
}
safe_snprintf(tmp,sizeof(tmp),"%s%s",cfg.temp_dir,title);
if(!fexistcase(str2) && fexistcase(tmp))
mv(tmp,str2,0);
l=(long)flength(str2);
if(l>0)
bprintf(text[FileNBytesReceived],title,ultoac(l,tmp));
else {
bprintf(text[FileNotReceived],title);
remove(msgpath);
return(false);
}
}
bputs(text[WritingIndx]);
if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
errormsg(WHERE,ERR_OPEN,"MAIL",i);
return(false);
}
sprintf(smb.file,"%smail", cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(smb_fgetlength(smb.shd_fp)<1) { /* Create it if it doesn't exist */
smb.status.max_crcs=cfg.mail_maxcrcs;
smb.status.max_age=cfg.mail_maxage;
smb.status.max_msgs=0;
smb.status.attr=SMB_EMAIL;
if((i=smb_create(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_CREATE,smb.file,i,smb.last_error);
return(false);
}
}
if((i=smb_locksmbhdr(&smb))!=0) {
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error);
return(false);
}
length=(long)flength(msgpath)+2; /* +2 for translation string */
if(length&0xfff00000UL) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_LEN,msgpath,length);
return(false);
}
if((i=smb_open_da(&smb))!=0) {
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
if(cfg.sys_misc&SM_FASTMAIL)
offset=smb_fallocdat(&smb,length,1);
else
offset=smb_allocdat(&smb,length,1);
smb_close_da(&smb);
if((instream=fnopen(&file,msgpath,O_RDONLY|O_BINARY))==NULL) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
errormsg(WHERE,ERR_OPEN,msgpath,O_RDONLY|O_BINARY);
return(false);
}
setvbuf(instream,NULL,_IOFBF,2*1024);
smb_fseek(smb.sdt_fp,offset,SEEK_SET);
xlat=XLAT_NONE;
smb_fwrite(&smb,&xlat,2,smb.sdt_fp);
x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
while(!feof(instream)) {
memset(buf,0,x);
j=fread(buf,1,x,instream);
if(j<1)
break;
if(j>1 && (j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
buf[j-1]=buf[j-2]=0;
if(cfg.mail_maxcrcs) {
for(i=0;i<j;i++)
crc=ucrc32(buf[i],crc);
}
smb_fwrite(&smb,buf,j,smb.sdt_fp);
x=SDT_BLOCK_LEN;
}
smb_fflush(smb.sdt_fp);
fclose(instream);
crc=~crc;
memset(&msg,0,sizeof(smbmsg_t));
msg.hdr.version=smb_ver();
msg.hdr.attr=msgattr;
if(mode&WM_FILE)
msg.hdr.auxattr|=MSG_FILEATTACH;
msg.hdr.when_written.time=msg.hdr.when_imported.time=time32(NULL);
msg.hdr.when_written.zone=msg.hdr.when_imported.zone=sys_timezone(&cfg);
if(cfg.mail_maxcrcs) {
i=smb_addcrc(&smb,crc);
if(i) {
smb_freemsgdat(&smb,offset,length,1);
smb_unlocksmbhdr(&smb);
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
attr(cfg.color[clr_err]);
bputs(text[CantPostMsg]);
return(false);
}
}
msg.hdr.offset=offset;
username(&cfg,usernumber,str);
smb_hfield_str(&msg,RECIPIENT,str);
sprintf(str,"%u",usernumber);
smb_hfield_str(&msg,RECIPIENTEXT,str);
SAFECOPY(str,useron.alias);
smb_hfield_str(&msg,SENDER,str);
sprintf(str,"%u",useron.number);
smb_hfield_str(&msg,SENDEREXT,str);
if(useron.misc&NETMAIL) {
if(useron.rest&FLAG('G'))
smb_hfield_str(&msg,REPLYTO,useron.name);
nettype=smb_netaddr_type(useron.netmail);
if(nettype!=NET_NONE && nettype!=NET_UNKNOWN) {
smb_hfield(&msg,REPLYTONETTYPE,sizeof(nettype),&nettype);
smb_hfield_str(&msg,REPLYTONETADDR,useron.netmail);
}
}
/* Security logging */
msg_client_hfields(&msg,&client);
smb_hfield_str(&msg,SENDERSERVER,startup->host_name);
smb_hfield_str(&msg,SUBJECT,title);
/* Generate FidoNet Program Identifier */
smb_hfield_str(&msg,FIDOPID,msg_program_id(pid));
if(editor!=NULL)
smb_hfield_str(&msg,SMB_EDITOR,editor);
smb_dfield(&msg,TEXT_BODY,length);
i=smb_addmsghdr(&smb,&msg,SMB_SELFPACK); // calls smb_unlocksmbhdr()
smb_close(&smb);
smb_stack(&smb,SMB_STACK_POP);
smb_freemsgmem(&msg);
if(i!=SMB_SUCCESS) {
smb_freemsgdat(&smb,offset,length,1);
errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error);
return(false);
}
if(usernumber==1)
logon_fbacks++;
else
logon_emails++;
user_sent_email(&cfg, &useron, 1, usernumber==1);
bprintf(text[Emailed],username(&cfg,usernumber,tmp),usernumber);
safe_snprintf(str,sizeof(str),"%s sent e-mail to %s #%d"
,useron.alias,username(&cfg,usernumber,tmp),usernumber);
logline("E+",str);
if(mode&WM_FILE && online==ON_REMOTE)
autohangup();
if(msgattr&MSG_ANONYMOUS) /* Don't tell user if anonymous */
return(true);
for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
getnodedat(i,&node,0);
if(node.useron==usernumber && !(node.misc&NODE_POFF)
&& (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
safe_snprintf(str,sizeof(str),text[EmailNodeMsg],cfg.node_num,useron.alias);
putnmsg(&cfg,i,str);
break;
}
}
if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
safe_snprintf(str,sizeof(str),text[UserSentYouMail],useron.alias);
putsmsg(&cfg,usernumber,str);
}
return(true);
}
/*!
onPaint does all the rendering for one frame from scratch with OpenGL (in core
profile).
*/
bool onPaint()
{
// Clear the color & depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// View transform: move the coordinate system away from the camera
_viewMatrix.identity();
_viewMatrix.translate(0, 0, _camZ);
// View transform: rotate the coordinate system increasingly by the mouse
_viewMatrix.rotate(_rotX + _deltaX, 1,0,0);
_viewMatrix.rotate(_rotY + _deltaY, 0,1,0);
// Transform light position & direction into view space
SLVec3f lightPosVS = _viewMatrix * _lightPos;
// The light dir is not a position. We only take the rotation of the mv matrix.
SLMat3f viewRot = _viewMatrix.mat3();
SLVec3f lightDirVS = viewRot * _lightDir;
// Rotate the model so that we see the square from the front side
// or the earth from the equator.
_modelMatrix.identity();
_modelMatrix.rotate(90, -1,0,0);
// Build the combined model-view and model-view-projection matrix
SLMat4f mvp(_projectionMatrix);
SLMat4f mv(_viewMatrix * _modelMatrix);
mvp.multiply(mv);
// Build normal matrix
SLMat3f nm(mv.inverseTransposed());
// Pass the matrix uniform variables
glUniformMatrix4fv(_mvMatrixLoc, 1, 0, (float*)&mv);
glUniformMatrix3fv(_nMatrixLoc, 1, 0, (float*)&nm);
glUniformMatrix4fv(_mvpMatrixLoc, 1, 0, (float*)&mvp);
// Pass lighting uniforms variables
glUniform4fv(_globalAmbiLoc, 1, (float*)&_globalAmbi);
glUniform3fv(_lightPosVSLoc, 1, (float*)&lightPosVS);
glUniform3fv(_lightDirVSLoc, 1, (float*)&lightDirVS);
glUniform4fv(_lightAmbientLoc, 1, (float*)&_lightAmbient);
glUniform4fv(_lightDiffuseLoc, 1, (float*)&_lightDiffuse);
glUniform4fv(_lightSpecularLoc, 1, (float*)&_lightSpecular);
glUniform4fv(_matAmbientLoc, 1, (float*)&_matAmbient);
glUniform4fv(_matDiffuseLoc, 1, (float*)&_matDiffuse);
glUniform4fv(_matSpecularLoc, 1, (float*)&_matSpecular);
glUniform4fv(_matEmissiveLoc, 1, (float*)&_matEmissive);
glUniform1f (_matShininessLoc, _matShininess);
glUniform1i (_texture0Loc, 0);
//////////////////////
// Draw with 2 VBOs //
//////////////////////
// Enable all of the vertex attribute arrays
glEnableVertexAttribArray(_pLoc);
glEnableVertexAttribArray(_nLoc);
glEnableVertexAttribArray(_tLoc);
// Activate VBOs
glBindBuffer(GL_ARRAY_BUFFER, _vboV);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboI);
// Activate Texture
glBindTexture(GL_TEXTURE_2D, _textureID);
// For VBO only offset instead of data pointer
GLsizei stride = sizeof(VertexPNT);
GLsizei offsetN = sizeof(SLVec3f);
GLsizei offsetT = sizeof(SLVec3f) + sizeof(SLVec3f);
glVertexAttribPointer(_pLoc, 3, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribPointer(_nLoc, 3, GL_FLOAT, GL_FALSE, stride, (void*)offsetN);
glVertexAttribPointer(_tLoc, 2, GL_FLOAT, GL_FALSE, stride, (void*)offsetT);
////////////////////////////////////////////////////////
// Draw cube model triangles by indexes
glDrawElements(GL_TRIANGLES, _numI, GL_UNSIGNED_INT, 0);
////////////////////////////////////////////////////////
// Deactivate buffers
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// Disable the vertex arrays
glDisableVertexAttribArray(_pLoc);
glDisableVertexAttribArray(_nLoc);
glDisableVertexAttribArray(_tLoc);
// Check for errors from time to time
GETGLERROR;
// Fast copy the back buffer to the front buffer. This is OS dependent.
glfwSwapBuffers(window);
// Calculate frames per second
char title[255];
static float lastTimeSec = 0;
float timeNowSec = (float)glfwGetTime();
float fps = calcFPS(timeNowSec-lastTimeSec);
sprintf(title, "Sphere, %d x %d, fps: %4.0f", _resolution, _resolution, fps);
glfwSetWindowTitle(window, title);
lastTimeSec = timeNowSec;
// Return true to get an immediate refresh
return true;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int EMMPMInputParser::parseCLIArguments(int argc, char* argv[], EMMPM_Data* inputs)
{
if ( NULL == inputs)
{
printf("The EMMPM_Inputs pointer was null. Returning early.\n");
return -1;
}
TCLAP::CmdLine cmd("", ' ', EMMPMLib::Version::Complete().toStdString());
TCLAP::ValueArg<std::string> in_inputFile("i", "inputfile", "Image File to be used as input", true, "", "");
cmd.add(in_inputFile);
TCLAP::ValueArg<std::string> in_outputFile("o", "outputfile", "The Image Output File", true, "", "");
cmd.add(in_outputFile);
TCLAP::ValueArg<float> in_beta("b", "beta", "Beta Value", false, 1.0, "1.0");
cmd.add(in_beta);
TCLAP::ValueArg<float> in_gamma("g", "gamma", "Gamma Value", false, 0.0f, "0.0");
cmd.add(in_gamma);
TCLAP::ValueArg<int> in_emIter("e", "emIter", "Number of EM Iterations", false, 5, "5");
cmd.add(in_emIter);
TCLAP::ValueArg<int> in_mpmIter("m", "mpmIter", "Number of MPM Iterations", false, 5, "5");
cmd.add(in_mpmIter);
TCLAP::ValueArg<int> in_numClasses("n", "numClasses", "The Number of classes or phases in the material", false, 2, "2");
cmd.add(in_numClasses);
TCLAP::SwitchArg in_verbose("v", "verbose", "Verbose Output", false);
cmd.add(in_verbose);
TCLAP::SwitchArg simAnneal("s", "simanneal", "Use Simulated Annealing", false);
cmd.add(simAnneal);
TCLAP::ValueArg<int> initType("z", "inittype", "The initialization algorithm that should be performed", false, 0, "1");
cmd.add(initType);
TCLAP::ValueArg<std::string> initcoords("", "coords", "The upper left (x,y) and lower right (x,y) pixel coordinate sets of each class to be used in the initialization algorithm where each set is separated by a colon ':'. An example is 487,192,507,212:0,332,60,392 for 2 class system.", false, "", "");
cmd.add(initcoords);
TCLAP::ValueArg<std::string> graytable( "", "graytable", "Comma separated list of grayscale values for each class. This can be used to combine classes together at file writing time.", false, "", "");
cmd.add(graytable);
TCLAP::ValueArg<float> beta_e("", "beta_e", "Gradient Penalty Weight", false, 0.0, "0.0");
cmd.add(beta_e);
TCLAP::ValueArg<float> beta_c("", "beta_c", "Curvature Penalty Weight", false, 0.0, "0.0");
cmd.add(beta_c);
TCLAP::ValueArg<float> rmax("", "rmax", "Maximum Radius for Curvature Morphalogical Filter", false, 15.0, "15.0");
cmd.add(rmax);
TCLAP::ValueArg<int> em_loop_delay("", "emLoopDelay", "Number of EM Loops to delay before applying the Morphological Filter", false, 1, "1");
cmd.add(em_loop_delay);
TCLAP::ValueArg<std::string> mv("", "mv", "Pairs of Mean,Sigma initial values for each class where each set is separated by a ':'. Example for 2 classes is: 121.3,22.8:205.2,45.0", false, "", "");
cmd.add(mv);
if (argc < 2)
{
std::cout << "EM/MPM Command Line Version " << cmd.getVersion() << std::endl;
std::vector<std::string> args;
args.push_back(argv[0]);
args.push_back("-h");
cmd.parse(args);
return -1;
}
try
{
int error = 0;
cmd.parse(argc, argv);
inputs->in_beta = in_beta.getValue();
for(int i = 0; i < EMMPM_MAX_CLASSES; i++)
{
inputs->w_gamma[i] = in_gamma.getValue();
}
inputs->mpmIterations = in_mpmIter.getValue();
inputs->emIterations = in_emIter.getValue();
inputs->classes = in_numClasses.getValue();
inputs->verbose = in_verbose.getValue();
inputs->simulatedAnnealing = simAnneal.getValue();
inputs->input_file_name = copyFilenameToNewCharBuffer(in_inputFile.getValue() );
if (inputs->input_file_name == NULL)
{
std::cout << "There was an error parsing the input file name. Did you use the '-i' argument to set an input file?" << std::endl;
return -1;
}
inputs->output_file_name = copyFilenameToNewCharBuffer(in_outputFile.getValue() );
if (inputs->output_file_name == NULL)
{
std::cout << "There was an error parsing the output file name. Did you use the '-o' argument to set an input file?" << std::endl;
return -1;
}
if (inputs->initType == EMMPM_UserInitArea)
{
error = parseInitCoords(initcoords.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the command line arguments for the initialization coordinates." << std::endl;
return -1;
}
}
if (inputs->initType == EMMPM_ManualInit)
{
error = parseMuSigmaValues(mv.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the command line arguments for the mean and variance values" << std::endl;
return -1;
}
}
if (graytable.getValue().empty() == false)
{
error = parseGrayTable(graytable.getValue(), inputs);
if (error < 0)
{
std::cout << "There was an error parsing the Gray Level Table." << std::endl;
return -1;
}
}
else // Create a default gray level table
{
int n = inputs->classes - 1;
for (int value = 0; value < inputs->classes; ++value)
{
unsigned int argb = 0xFF000000; // Black
unsigned char* ptr = reinterpret_cast<unsigned char*>(&argb);
ptr[1] = value * 255 / n;
ptr[2] = value * 255 / n;
ptr[3] = value * 255 / n;
inputs->colorTable[value] = argb;
}
}
/* Parse the Gradient Penalty Weighting (Beta E) from the command line */
if (beta_e.getValue() > 0.0)
{
inputs->useGradientPenalty = 1;
inputs->beta_e = beta_e.getValue();
}
/* Parse the Curvature Penalty Arguments */
if (beta_c.getValue() > 0.0)
{
inputs->useCurvaturePenalty = 1;
inputs->beta_c = beta_c.getValue();
inputs->r_max = rmax.getValue();
inputs->ccostLoopDelay = em_loop_delay.getValue();
}
}
catch (TCLAP::ArgException& e)
{
std::cerr << " error: " << e.error() << " for arg " << e.argId() << std::endl;
std::cout << "** Unknown Arguments. Displaying help listing instead. **" << std::endl;
return -1;
}
return 0;
}
I rsh(A a,I r,I *d){R g=(PFI)rsh,a->c==1?(mv(a->d,d,a->r=r),ic(a)):(I)gc(a->t,r,a->n,d,a->p);}
