void FileBrowserDialog::fetchDirents(bool force_refresh)
{
if (repo_.encrypted && !data_mgr_->isRepoPasswordSet(repo_.id)) {
SetRepoPasswordDialog password_dialog(repo_, this);
if (password_dialog.exec() != QDialog::Accepted) {
reject();
return;
} else {
data_mgr_->setRepoPasswordSet(repo_.id, password_dialog.password());
}
}
if (!force_refresh) {
QList<SeafDirent> dirents;
if (data_mgr_->getDirents(repo_.id, current_path_, &dirents, ¤t_readonly_)) {
updateTable(dirents);
return;
}
}
showLoading();
data_mgr_->getDirentsFromServer(repo_.id, current_path_);
}
void MainWindow::on_addTask_button_clicked()
{
insertItem *dialogBox = new insertItem;
connect(dialogBox, SIGNAL(finished(int)), dialogBox, SLOT(deleteLater()));
if( dialogBox->exec() )
{
//db stuff
QSqlQuery query ("insert into tasks (Task, DueDate, Completed, Priority, Notes) values (:name, :dueDate, :completed, :priority, :notes)");
query.bindValue(0, dialogBox->get_task());
query.bindValue(1, dialogBox->get_dueDate());
query.bindValue(2, dialogBox->get_isCompleted());
query.bindValue(3, dialogBox->get_priority());
query.bindValue(4, dialogBox->get_notes());
if(query.exec())
{
updateTable();
}
ui->editTask_button->setDisabled(true);
ui->removeTask_button->setDisabled(true);
}
}
void TunerDetector::prepare(float targetFrequency)
{
method = (targetFrequency < 200) ? autocorr : lookup;
if (method == lookup)
{
TunerDetector::targetFrequency = targetFrequency;
for (size_t table = 0; table < offsets.size(); table++)
{
float stepFrequency = freqShift(targetFrequency, offsets[table]);
updateTable(table, stepFrequency);
}
}
else if (method == autocorr)
{
float targetPeriod = SAMPLE_RATE / targetFrequency;
// TODO: check against buf.size() here
const float fiveHalfsteps = 1.3348f;
maxPeriod = (int)ceil(SAMPLE_RATE / targetFrequency * fiveHalfsteps);
minPeriod = (int)round(SAMPLE_RATE / targetFrequency / fiveHalfsteps);
}
}
//table
void MainWindow::init_db()
{
// create settings.ini file if it doesn't exist
if(!QFile(DataLoc.at(0) + "/settings.ini").exists())
{
settings->setValue("mainWindowGeometry", saveGeometry());
settings->setValue("mainWindowState", saveState());
settings->setValue("Sorting/row", 0);
settings->setValue("Sorting/type", 0);
settings->setValue("AutoUpdate/enabled", true);
settings->setValue("portableMode", false);
settings->sync();
}
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(DataLoc.at(0) + "/tasks.db");
db.open();
db.exec("create table if not exists tasks (Task, DueDate, Completed, Priority, Notes)");
db.exec("create table if not exists sort_preferences (id PRIMARY KEY, row, type)");
all_model = new QSqlTableModel(this, db);
ui->tableView->setModel(all_model);
updateTable();
}
TreeSubWindow::TreeSubWindow(PhyView* phyview, TreeDocument* document, TreeDrawing* td):
phyview_(phyview), treeDocument_(document), treeCanvas_()
{
setAttribute(Qt::WA_DeleteOnClose);
setWindowFilePath(QtTools::toQt(treeDocument_->getFilePath()));
treeDocument_->addView(this);
treeCanvas_ = new TreeCanvas();
treeCanvas_->setTree(treeDocument_->getTree());
treeCanvas_->setTreeDrawing(*td);
treeCanvas_->setMinimumSize(400, 400);
treeCanvas_->addMouseListener(phyview_->getMouseActionListener());
connect(treeCanvas_, SIGNAL(drawingChanged()), phyview, SLOT(clearSearchResults()));
nodeEditor_ = new QTableWidget();
nodeEditor_->setColumnCount(3);
connect(nodeEditor_, SIGNAL(itemChanged(QTableWidgetItem *)), this, SLOT(nodeEditorHasChanged(QTableWidgetItem*)));
QStringList labels;
labels.append(tr("Id"));
labels.append(tr("Name"));
labels.append(tr("Branch length"));
nodeEditor_->setHorizontalHeaderLabels(labels);
splitter_ = new QSplitter(this);
splitter_->addWidget(treeCanvas_);
splitter_->addWidget(nodeEditor_);
splitter_->setCollapsible(0, true);
splitter_->setCollapsible(1, true);
//Move the splitter to the right:
QList<int> currentSizes = splitter_->sizes();
currentSizes[0] = currentSizes[0] + currentSizes[1];
currentSizes[1] = 0;
splitter_->setSizes(currentSizes);
setMinimumSize(400, 400);
setWidget(splitter_);
updateTable();
}
long DccDialog::onClear(FXObject*, FXSelector, void*)
{
if(!dxirc::instance()->getDccFilesList().no())
return 1;
for(FXint i=dxirc::instance()->getDccFilesList().no()-1; i>-1; i--)
{
if(dxirc::instance()->getDccFilesList()[i].type == DCC_IN || dxirc::instance()->getDccFilesList()[i].type == DCC_PIN)
{
if(dxirc::instance()->getDccFilesList()[i].currentPosition >= dxirc::instance()->getDccFilesList()[i].size)
{
dxirc::instance()->getDccFilesList().erase(i);
}
}
else
{
if(dxirc::instance()->getDccFilesList()[i].finishedPosition >= dxirc::instance()->getDccFilesList()[i].size)
{
dxirc::instance()->getDccFilesList().erase(i);
}
}
}
updateTable();
return 1;
}
int processODRmsg(struct ODRmsg *m, struct sockaddr *sa)
{
int gr = 0, s = 0;
char temp[16];
struct demux *found;
struct sockaddr_ll *sall;
struct ODRmsg msg, RREP, RREQ;
sall = (struct sockaddr_ll *) sa;
msg = *m;
if(msg.type == 0)
{
printf("Received RREQ\n");
//Update the routing table with information about the neighbor
updateTable(msg.src_ip, neighbor, sall->sll_ifindex, ntohs(msg.hopcount), ntohs(msg.forced_discovery));
//If we're the destination, send an RREP
if(isDestination(msg.dest_ip))
{
//Send an RREP to your neighbor
if(ntohs(msg.RREPsent) == 0)
{
strncpy(RREP.src_ip, canonical, 16);
strncpy(RREP.dest_ip, msg.src_ip, 16);
RREP.hopcount = msg.hopcount;
RREP.forced_discovery = msg.forced_discovery;
sendRREP(RREP, sall->sll_ifindex, -1, msg.forced_discovery);
}
else
printf("RREP already sent, do nothing\n");
}
else
{
//Check for a route in the table
gr = gotFreshRoute(msg.dest_ip);
if(gr == -1) //If there's no route in the table, send an RREQ
sendRREQ(msg, sall->sll_ifindex, msg.forced_discovery, 0);
else //If there's a fresh route, send an RREP
{
if(ntohs(msg.RREPsent) == 0)
{
strncpy(RREP.src_ip, msg.dest_ip, 16);
strncpy(RREP.dest_ip, msg.src_ip, 16);
RREP.hopcount = routing_table[gr].hops;
RREP.forced_discovery = msg.forced_discovery;
sendRREP(RREP, sall->sll_ifindex, -1, msg.forced_discovery);
}
else
printf("RREP already sent, do nothing\n");
}
}
}
else if(msg.type == 1)
{
printf("Received RREP\n");
//Update the table
updateTable(msg.src_ip , neighbor, sall->sll_ifindex, ntohs(msg.hopcount), ntohs(msg.forced_discovery)); //src_ip or dest_ip?
if(!isDestination(msg.dest_ip))
{
//If you have a route, forward the RREP
gr = gotFreshRoute(msg.dest_ip);
if(gr != -1)
sendRREP(RREP, routing_table[gr].index, gr, msg.forced_discovery);
else
printf("No route?\n");
}
}
else if(msg.type == 2)
{
printf("Received application payload\n");
//Update the table
updateTable(msg.src_ip, neighbor, sall->sll_ifindex, ntohs(msg.hopcount), ntohs(msg.forced_discovery)); //src_ip or dest_ip?
//If this is the destination of the app payload, send it to the peer process
if(isDestination(msg.dest_ip))
{
printf("Forwarding to peer process\n");
sendtoDest(msg);
}
else
{
//Find a route
gr = gotFreshRoute(msg.dest_ip);
if(gr != -1)
{
//If there's no route, send an RREQ, wait for an RREP, and forward the message
strncpy(RREQ.src_ip, canonical, 16);
strncpy(RREQ.dest_ip, msg.dest_ip, 16);
RREQ.hopcount = htons(0);
sendRREQ(RREQ, sall->sll_ifindex, -1, 1);
if(waitforRREP(msg.dest_ip) == 0)
sendAPPmsg(&msg, gr);
else
printf("waitforRREP failed\n");
}
else
sendAPPmsg(&msg, gr);
}
}
else
printf("Message has invalid type: %d\n", ntohs(msg.type));
return 0;
}
void FileBrowserDialog::onGetDirentsSuccess(const QList<SeafDirent>& dirents)
{
updateTable(dirents);
}
// SLOT function to set data at specified address
// Also emits a signal to update the memory table
// on the GUI
void memory::setDataAtAddr(word addr, word data)
{
dataMem[addr] = data;
QString dataStr = toHexString(data);
emit updateTable(addr, dataStr);
}
void PageItemAttributes::clearEntries()
{
localAttributes.clear();
updateTable();
}
void ClinicInternalPaymentForm::create()
{
connect(m_startDateEdit, SIGNAL(dateChanged(QDate)), this, SLOT(updateTable()));
connect(m_endDateEdit, SIGNAL(dateChanged(QDate)), this, SLOT(updateTable()));
}
void ProcessMonitor::processUpdated()
{
updateTable();
saveProcessList();
}
void DlgDictionary::on_editSearch_textEdited(const QString& text)
{
updateTable(text);
}
void ChatServer::processMessage(AuthorizationRequest *msg, QTcpSocket *socket)
//processing authorization request
//here we need to check whether user exists in table or not
//YOBA ETO YA, PSHH-PSSHHH
//and we need to form authorization answer and send it to client
{
if (!msg)
{
QString log = "Error processing authprization request- message is empty";
emit serverLog(esMinor, log);
return;
}
AuthorizationAnswer *answer = new AuthorizationAnswer();
switch (m_clientList.authorize(msg->username, msg->password, socket))
{
case GeneralClientList::arAllreadyAuthorized:
{
answer->authorizationResult = false;
answer->denialReason = "User allready authorized";
break;
}
case GeneralClientList::arWrongAuthData:
{
answer->authorizationResult = false;
answer->denialReason = "Wrong username or password";
break;
}
case GeneralClientList::arAuthSuccess:
{
answer->authorizationResult = true;
break;
}
}
sendMessageToClient(socket, answer);
if (answer->authorizationResult)
{
ChatClient client = m_clientList.getClient(msg->username);
client.setUserState("Online");
m_clientList.updateClient(client);
emit updateTable("clients");
QStringList channels = m_clientList.getChannelsForClient(msg->username).keys();
ChannelSystemMessage *informMsg = new ChannelSystemMessage();
ChannelUserList *updateListMsg = new ChannelUserList();
informMsg->message = msg->username + " entered chat.";
for (int i = 0; i < channels.count(); ++i)
{
informMsg->channelName = channels[i];
updateListMsg->channelName = channels[i];
ChatChannel channel = m_clientList.getChannel(channels[i]);
for(int k = 0; k < channel.userList.count(); k++)
{
//FIXME: GOVNOKOD
updateListMsg->userList.insert(channel.userList[k], getSendableState(channel.userList[k]));
}
for (int j = 0; j < channel.userList.count(); j++)
{
QString username = channel.userList[j];
if (username != msg->username)
{
sendMessageToClient(username, informMsg);
sendMessageToClient(username, updateListMsg);
}
}
}
delete updateListMsg;
delete informMsg;
}
delete answer;
}
void FileBrowserDialog::onGetDirentsSuccess(bool current_readonly, const QList<SeafDirent>& dirents)
{
current_readonly_ = current_readonly;
updateTable(dirents);
}
void MainWindow::update() {
qDebug() << "MainWindow::update() - Running";
updateTable();
if(network != NULL) {
if(netgraphics != NULL) {
delete netgraphics;
scene->clear();
}
netgraphics = new NetworkGraphics(network, scene, this);
netgraphics->updateNetwork();
//ui->graphicsView->setMouseTracking(true);
/*QList<raw_address> addresses = network->getAddressList();
qDebug() << "Have" << addresses.count() << "addresses";
for(int i=0; i < addresses.count(); i++){
raw_address addr = addresses.at(i);
qDebug() << "\t" << i << ":" << addr.toString().c_str();
}
QList<raw_address> parents = network->getTopLevelAddresses();
qDebug() << "Have" << parents.count() << "top level parents";
for(int i=0; i < parents.count(); i++){
raw_address addr = parents.at(i);
QList<NetNode*> children = network->getChildNodes(addr);
QMultiMap<uint8_t, NetNode*> branch = network->getBranch(addr);
qDebug() << "\t" << i << ":" << addr.toString().c_str()
<< "\thas" << children.count()
<< "children branch contains"
<<branch.size()<<"nodes";
QList<uint8_t> layers = branch.uniqueKeys();
qDebug() << "\tHas " << layers.count() <<" layers";
for(int j=0; j<layers.count(); j++){
QList<NetNode*> nodes = branch.values(layers[j]);
QString outputStr;
QTextStream stream(&outputStr);
stream<<"\t\tLayer["<<j<<"] Size="<<nodes.count()<<" ";
for(int k=0; k<nodes.count(); k++){
NetNode* node = nodes[k];
stream << node->getAddress().toString().c_str() << " ";
}
qDebug() << outputStr;
}
}*/
}
}
int main(int argc, char *argv[])
{
int sockfd[NUMROUTERS]; /* socket */
int clientlen; /* byte size of client's address */
struct sockaddr_in serveraddr[NUMROUTERS]; /* server's address */
struct sockaddr_in clientaddr; /* client's address */
struct hostent *hostp; /* client host info */
int buf[BUFSIZE]; /* message buffer */
char *hostaddrp; /* dotted decimal host address string */
int optval; /* flag value for setsockopt */
int n; /* message byte size */
int count;
fd_set socks;
bool stableState = false;
int nKills = 0;
char * filepath = "sample.txt";
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 50000;
int killedRouters[NUMROUTERS] = {0};
/* for testing */
struct router tableA, tableB, tableC, tableD, tableE, tableF;
/*
struct router tableA = {
INDEXA,
{ 'A', NULL, NULL, NULL, NULL, NULL },
{ 0, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX },
{ ROUTERA, NULL, NULL, NULL, NULL, NULL },
{ ROUTERA, NULL, NULL, NULL, NULL, NULL }
};
*/
/*
struct router tableA = {
INDEXA,
{ 'A', NULL, NULL, NULL, NULL, NULL },
{ 0, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX },
{ ROUTERA, NULL, NULL, NULL, NULL, NULL },
{ ROUTERA, NULL, NULL, NULL, NULL, NULL }
};
struct router tableB = {
INDEXB,
{ NULL, 'B', NULL, NULL, NULL, NULL },
{ INT_MAX, 0, INT_MAX, INT_MAX, INT_MAX, INT_MAX },
{ NULL, ROUTERB, NULL, NULL, NULL, NULL },
{ NULL, ROUTERB, NULL, NULL, NULL, NULL }
};
struct router tableC = {
INDEXC,
{ NULL, NULL, 'C', NULL, NULL, NULL },
{ INT_MAX, INT_MAX, 0, INT_MAX, INT_MAX, INT_MAX },
{ NULL, NULL, ROUTERC, NULL, NULL, NULL },
{ NULL, NULL, ROUTERC, NULL, NULL, NULL }
};
struct router tableD = {
INDEXD,
{ NULL, NULL, NULL, 'D', NULL, NULL },
{ INT_MAX, INT_MAX, INT_MAX, 0, INT_MAX, INT_MAX },
{ NULL, NULL, NULL, ROUTERD, NULL, NULL },
{ NULL, NULL, NULL, ROUTERD, NULL, NULL }
};
struct router tableE = {
INDEXE,
{ NULL, NULL, NULL, NULL, 'E', NULL },
{ INT_MAX, INT_MAX, INT_MAX, INT_MAX, 0, INT_MAX },
{ NULL, NULL, NULL, NULL, ROUTERE, NULL },
{ NULL, NULL, NULL, NULL, ROUTERE, NULL }
};
struct router tableF = {
INDEXF,
{ NULL, NULL, NULL, NULL, NULL, 'F' },
{ INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, 0 },
{ NULL, NULL, NULL, NULL, NULL, ROUTERF },
{ NULL, NULL, NULL, NULL, NULL, ROUTERF }
};
*/
struct router **network = malloc(NUMROUTERS * sizeof(struct router*));
int i;
for (i=0; i<NUMROUTERS; i++) {
network[i] = malloc(NUMROUTERS * sizeof(struct router));
}
network[0] = &tableA;
network[1] = &tableB;
network[2] = &tableC;
network[3] = &tableD;
network[4] = &tableE;
network[5] = &tableF;
/*
for(i=0;i < NUMROUTERS; i++)
{
printRouter(network[i]);
}
*/
re_initialize:
/*
if (nKills > 0)
{
printf("\nenter\n");
}
*/
reinitializeTables(&tableA, &tableB, &tableC, &tableD, &tableE, &tableF);
/*
printf("***\n***AFTER REINIT:***\n***");
for(i=0;i < NUMROUTERS; i++)
{
printRouter(network[i]);
}
*/
struct matrix neighborMatrix = initializeFromFile(&tableA, &tableB, &tableC, &tableD, &tableE, &tableF, killedRouters);
/* end testing */
/*
printf("***\n***SECOND PRINT:***\n***");
for(i=0;i < NUMROUTERS; i++)
{
printRouter(network[i]);
}
int g;
for (i=0; i < NUMROUTERS; i++)
{
for (g=0; g < NUMROUTERS; g++)
printf("%d\t", neighborMatrix.r[i][g]);
printf("\n");
}
*/
initializeOutputFiles(network);
for (i=0; i<NUMROUTERS; i++) {
/* create parent socket */
if ( (sockfd[i] = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
error("Error opening socket");
/* server can be rerun immediately after killed */
optval = 1;
setsockopt(sockfd[i], SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof(int));
setsockopt(sockfd[i], SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval));
/* build server's Internet address */
bzero((char *) &serveraddr[i], sizeof(serveraddr[i]));
serveraddr[i].sin_family = AF_INET;
serveraddr[i].sin_addr.s_addr = htonl(INADDR_ANY);
switch(i+10000) {
case ROUTERA:
serveraddr[i].sin_port = htons(ROUTERA);
break;
case ROUTERB:
serveraddr[i].sin_port = htons(ROUTERB);
break;
case ROUTERC:
serveraddr[i].sin_port = htons(ROUTERC);
break;
case ROUTERD:
serveraddr[i].sin_port = htons(ROUTERD);
break;
case ROUTERE:
serveraddr[i].sin_port = htons(ROUTERE);
break;
case ROUTERF:
serveraddr[i].sin_port = htons(ROUTERF);
break;
}
/* bind: associate parent socket with port */
if (bind(sockfd[i], (struct sockaddr *) &serveraddr[i], sizeof(serveraddr[i])) < 0)
error("Error on binding");
}
clientlen = sizeof(clientaddr);
int serverlen = sizeof(serveraddr[0]);
int start;
/* begin by having ROUTERA send DV to one neighbor */
/* for this implementation, ROUTERA will send to ROUTERB */
struct router* starter;
switch (argv[1][0])
{
case 'A':
starter = &tableA;
start = INDEXA;
break;
case 'B':
starter = &tableB;
start = INDEXB;
break;
case 'C':
starter = &tableC;
start = INDEXC;
break;
case 'D':
starter = &tableD;
start = INDEXD;
break;
case 'E':
starter = &tableE;
start = INDEXE;
break;
case 'F':
starter = &tableF;
start = INDEXF;
break;
}
//exit(0);
/*
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[0][i] != -1) {
start = neighborMatrix.r[0][i];
break;
}
}
*/
// start is 0 thru 5
//in this case, start=1
//printRouter(starter);
memset(buf, 0, BUFSIZE);
tableToBuffer(starter, &buf);
// tableToBuffer(&tableA, &buf);
// printf("Starting router: %d %c\n", start - 'A', start);
// n = sendto(sockfd[start - 'A'], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[start], clientlen);
n = sendto(sockfd[start], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[start], clientlen);
int nsocks = max(sockfd[0], sockfd[1]);
for (i=2; i<NUMROUTERS; i++) {
nsocks = max(nsocks, sockfd[i]);
}
int counterdd = 0;
count = 0;
printf("Stabilizing network...");
/* loop: wait for datagram, then echo it */
while (1) {
FD_ZERO(&socks);
for (i=0; i<NUMROUTERS; i++) {
FD_SET(sockfd[i], &socks);
}
if (select(nsocks+1, &socks, NULL, NULL, NULL) < 0) {
printf("Error selecting socket\n");
} else {
/* receives UDP datagram from client */
memset(buf, 0, BUFSIZE);
if (FD_ISSET(sockfd[0], &socks)) {
if ( (n = recvfrom(sockfd[0], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
error("Error receiving datagram from client\n");
struct router compTable;
bufferToTable(buf, &compTable);
if (updateTable(&tableA, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableA, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[0][i] != -1) {
n = sendto(sockfd[0], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[0][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (FD_ISSET(sockfd[1], &socks)) {
if ( (n = recvfrom(sockfd[1], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
{
error("Error receiving datagram from client\n");
printf("error\n");
}
struct router compTable;
bufferToTable(&buf, &compTable);
if (updateTable(&tableB, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableB, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[1][i] != -1) {
n = sendto(sockfd[1], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[1][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (FD_ISSET(sockfd[2], &socks)) {
if ( (n = recvfrom(sockfd[2], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
error("Error receiving datagram from client\n");
struct router compTable;
bufferToTable(&buf, &compTable);
if(updateTable(&tableC, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableC, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[2][i] != -1) {
n = sendto(sockfd[2], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[2][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (FD_ISSET(sockfd[3], &socks)) {
if ( (n = recvfrom(sockfd[3], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
error("Error receiving datagram from client\n");
struct router compTable;
bufferToTable(&buf, &compTable);
if(updateTable(&tableD, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableD, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[3][i] != -1) {
n = sendto(sockfd[3], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[3][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (FD_ISSET(sockfd[4], &socks)) {
if ( (n = recvfrom(sockfd[4], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
error("Error receiving datagram from client\n");
struct router compTable;
bufferToTable(&buf, &compTable);
if(updateTable(&tableE, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableE, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[4][i] != -1) {
n = sendto(sockfd[4], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[4][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (FD_ISSET(sockfd[5], &socks)) {
if ( (n = recvfrom(sockfd[5], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) < 0 )
error("Error receiving datagram from client\n");
struct router compTable;
bufferToTable(&buf, &compTable);
if(updateTable(&tableF, compTable) == false)
count++;
else
count = 0;
tableToBuffer(&tableF, &buf);
for (i=0; i<NUMROUTERS; i++) {
if (neighborMatrix.r[5][i] != -1) {
n = sendto(sockfd[5], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&serveraddr[neighborMatrix.r[5][i]], clientlen);
if (n < 0)
error("Error sending to client");
}
}
}
if (count >= NUMROUTERS * 2) {
for (i=0; i<NUMROUTERS; i++) {
outputTable(network[i], true);
}
stableState = true;
// printf("\n\nFINAL ROUTER INFO:\n\n");
// printf("ROUTER A:\n\n");
// printRouter(&tableA);
// printf("\n\nROUTER B:\n\n");
// printRouter(&tableB);
// printf("\n\nROUTER C:\n\n");
// printRouter(&tableC);
// printf("\n\nROUTER D:\n\n");
// printRouter(&tableD);
// printf("\n\nROUTER E:\n\n");
// printRouter(&tableE);
// printf("\n\nROUTER F:\n\n");
// printRouter(&tableF);
printf("[OK]\n\n");
choose_action:
printf("Press 1<ENTER> to kill a router\nPress 2<ENTER> to send packet across the network\nPress 3<ENTER> to profile the network\nPress 4<ENTER> to exit\n-> ");
// steady state
// scan for input to send a packe
int option, k; // kill router, or send packet from x to y
char toKill, srcRouter, dstRouter;
scanf("%d", &option);
switch (option)
{
case 1:
printf("Label of router to kill (A-F):\n-> ");
scanf("\n%c", &toKill);
printf("Killing router %c\n", toupper(toKill));
int n;
/*
struct timeval tv;
tv.tv_usec = 500000;
*/
for (k = 0; k < NUMROUTERS; k++)
{
printf("Clearing Router %c's input buffers...", (char) k + 'A');
FD_ZERO(&socks);
FD_SET(sockfd[k], &socks);
while ( (n = recvfrom(sockfd[k], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) > 0)
{
// printf("%d %d\n", k, n);
}
printf("[OK]\n");
}
reinitializeTopologyFile(toupper(toKill), nKills);
killedRouters[toupper(toKill) - 'A'] = 1;
nKills++;
goto re_initialize;
// will never reach this point
break;
case 2:
printf("Label of source router (A-F):\n-> ");
scanf("%c", &srcRouter);
srcRouter = getchar();
srcRouter = toupper(srcRouter);
printf("Label of destination router (A-F):\n-> ");
scanf("%c", &dstRouter);
dstRouter = getchar();
dstRouter = toupper(dstRouter);
printf("Routing a packet from Router %c to Router %c...", srcRouter, dstRouter);
struct packet p = { 'd', "message", srcRouter, dstRouter, 0, 0 };
forwardPacket(&p, network);
printf("[OK]\n\n");
goto choose_action;
break;
case 3:
printf("Routing tables:\n\n");
for (k = 0; k < NUMROUTERS; k++)
{
printf("\nRouter %c:\n\n", 'A' + k);
printRouter(network[k]);
}
goto choose_action;
break;
case 4:
printf("Killing all routers.\n");
/*
struct timeval tv;
tv.tv_usec = 500000;
*/
for (k = 0; k < NUMROUTERS; k++)
{
printf("Clearing Router %c's input buffers...", (char) k + 'A');
FD_ZERO(&socks);
FD_SET(sockfd[k], &socks);
while ( (n = recvfrom(sockfd[k], buf, BUFSIZE*sizeof(int), 0, (struct sockaddr *)&clientaddr, &clientlen)) > 0)
{
// printf("%d %d\n", k, n);
}
printf("[OK]\n");
}
break;
}
break;
}
}
}
}
int main(int args, char ** argv) {
misc::process_args(args, argv);
load_image(file_name[0], left_pyramid[0].rgb, left_pyramid[0].H, left_pyramid[0].W);
load_image(file_name[1], right_pyramid[0].rgb, right_pyramid[0].H, right_pyramid[0].W);
if (left_pyramid[0].H != right_pyramid[0].H || left_pyramid[0].W != right_pyramid[0].W) {
printf("The size of two pictures differ!! quit....");
return 0;
}
if (left_pyramid[0].H >= MAX_HEIGHT || right_pyramid[0].W >= MAX_WIDTH) {
printf("Input : %d x %d, program : %d %d\n", left_pyramid[0].H, left[0].W, MAX_HEIGHT, MAX_WIDTH);
puts("Image too big. change settings.h and re-compile.");
return 0;
}
timer.reset();
if (use_lab) {
left_pyramid[0].computeLab();
right_pyramid[0].computeLab();
}
for (int i = 0; i + 1 < levels; ++i) {
left_pyramid[i+1].shrinkPicture(left_pyramid[i+1].rgb, left_pyramid[i].rgb, left_pyramid[i].H, left_pyramid[i].W);
right_pyramid[i+1].shrinkPicture(right_pyramid[i+1].rgb, right_pyramid[i].rgb, right_pyramid[i].H, right_pyramid[i].W);
if (use_lab) {
left_pyramid[i+1].shrinkPicture(left_pyramid[i+1].lab, left_pyramid[i].lab, left_pyramid[i].H, left_pyramid[i].W);
right_pyramid[i+1].shrinkPicture(right_pyramid[i+1].lab, right_pyramid[i].lab, right_pyramid[i].H, right_pyramid[i].W);
}
/*save_image_rgb(shrinkname[i+1][0], left_pyramid[i+1].rgb,
left_pyramid[i+1].H, left_pyramid[i+1].W);*/
}
for (int lvl = levels - 1; lvl >= 0; -- lvl) {
int idx = lvl % OBJ_NUM;
left[idx].init(left_pyramid[lvl]);
right[idx].init(right_pyramid[lvl]);
if (lvl == levels - 1) {
left[idx].noPrediction(max_disparity / (1 << lvl));
} else {
DP::getSupportProb(left[idx].rgb, right[idx].rgb,
left[idx].H, left[idx].W, max_disparity / (1 << lvl));
DP::getProbMatrix(lvl, max_disparity / (1 << (lvl + 1)), max_disparity / (1 << lvl), dataset);
DP::getInterval(pixel_intv_threshold * (1 << lvl));
left[idx].readPrediction(left[(lvl + 1)%OBJ_NUM].disparity);
// left[idx].intersectInterval(left[(lvl + 1) % OBJ_NUM]);
}
// Now use the INTERVAL to find the new disparities.
left_pyramid[lvl].computeGradient();
right_pyramid[lvl].computeGradient();
left[idx].buildForest(tree_intv_threshold, use_lab);
left[idx].initDisparity();
updateTable(255 * 0.1);
left[idx].stereoMatch(right[idx], 1, use_lab);
misc::median_filter(left[idx].disparity, left[idx].H, left[idx].W, 3);
//save_image(layername[lvl][0], left[idx].disparity, left[idx].H, left[idx].W, scale * (1 << lvl));
} // end of layer iteration.
timer.check("all");
save_image(file_name[2], left[0].disparity, left[0].H, left[0].W, scale);
return 0;
}
void AliasDialog::create()
{
FXDialogBox::create();
updateTable();
setHeight(350);
}
void QEditAssessment::setQuestionList(QList<Question> qL)
{
updateTable(qL);
}
void DocumentItemAttributes::clearEntries()
{
localAttributes.clear();
updateTable();
}
void ProcessMonitor::showEvent(QShowEvent* event)
{
updateTable();
m_updateTimer.start();
event->accept();
}
long DccDialog::onTimeout(FXObject*, FXSelector, void*)
{
updateTable();
getApp()->addTimeout(this, DccDialog_UTIME, 1000);
return 1;
}
void MainWindow::on_eventComboBox_currentIndexChanged(int index)
{
std::vector<int> inputs = getInputs(index);
updateTable(inputs);
}
/**
* Use the ColumnEditor dialog to edit the currently selected column
* definition. Called when the "Edit" button is pressed.
*/
void DBEditor::editColumn()
{
QTreeWidgetItem *item = table->currentItem();
if (!item) {
return;
}
QString name = item->text(0);
QString oldName = name;
int index = info.Find(ceName [name.toUtf8()]);
int type = ceType (info[index]);
QString defaultVal = QString::fromUtf8(ceDefault (info[index]));
columnEditor->setName(name);
columnEditor->setType(type);
columnEditor->setTypeEditable(false);
columnEditor->setDefaultValue(defaultVal);
CalcNode *calcRoot = 0;
int decimals = 2;
if (type == CALC) {
calcRoot = calcMap[name];
decimals = decimalsMap[name];
// use a copy in case the edit is cancelled
if (calcRoot != 0) {
calcRoot = calcRoot->clone();
}
columnEditor->setCalculation(calcRoot, decimals);
}
bool finished = false;
bool aborted = false;
while (!finished) {
if (!columnEditor->exec()) {
finished = true;
aborted = true;
}
else {
name = columnEditor->name();
type = columnEditor->type();
defaultVal = columnEditor->defaultValue();
if (name != oldName) {
finished = (isValidName(name)
&& isValidDefault(type, defaultVal));
if (finished) {
int oldIndex = ceOldIndex (info[index]);
if (oldIndex != -1) {
renamedCols[oldIndex] = name;
}
renameColumnRefs(oldName, name);
}
}
else {
finished = isValidDefault(type, defaultVal);
}
}
}
calcRoot = columnEditor->calculation(&decimals);
if (!aborted) {
ceName (info[index]) = name.toUtf8();
ceDefault (info[index]) = defaultVal.toUtf8();
if (type == CALC) {
CalcNode *oldRoot = calcMap[oldName];
if (oldRoot != 0) {
delete oldRoot;
}
calcMap.remove(oldName);
decimalsMap.remove(oldName);
calcMap.insert(name, calcRoot);
decimalsMap.insert(name, decimals);
columnEditor->setCalculation(0, 2);
calcRoot = 0;
}
updateTable();
}
if (calcRoot != 0) {
delete calcRoot;
columnEditor->setCalculation(0, 2);
}
}
void DocumentItemAttributes::setup(ObjAttrVector *docItemAttrs)
{
localAttributes=*docItemAttrs;
updateTable();
}
void LandmarkBrowser::fetchHandler(QLandmarkAbstractRequest::State state)
{
if (state == QLandmarkAbstractRequest::FinishedState)
{
QLandmarkAbstractRequest *request = qobject_cast<QLandmarkAbstractRequest*> (sender());
if (!request)
return;
switch (request->type()) {
case QLandmarkAbstractRequest::ImportRequest : {
if (request->error() == QLandmarkManager::NoError) {
landmarkFetch->setOffset(currentLandmarkOffset);
landmarkFetch->start();
} else if (request->error() == QLandmarkManager::CancelError) {
// do nothing
} else {
QMessageBox::warning(this,"Warning", "Import Failed", QMessageBox::Ok, QMessageBox::NoButton);
progress->hide();
}
break;
}
case QLandmarkAbstractRequest::ExportRequest : {
if (request->error() == QLandmarkManager::NoError) {
progress->hide();
QMessageBox::information(this,"Finished", "Export Successful", QMessageBox::Ok, QMessageBox::NoButton);
} else if (request->error() == QLandmarkManager::CancelError) {
// do nothing
} else {
QMessageBox::warning(this,"Warning", "Export Failed", QMessageBox::Ok, QMessageBox::NoButton);
progress->hide();
}
break;
}
case QLandmarkAbstractRequest::LandmarkFetchRequest: {
if (landmarkFetch->error() == QLandmarkManager::NoError) {
if (currentLandmarkOffset < limit)
prevLandmarkButton->setEnabled(false);
else
prevLandmarkButton->setEnabled(true);
if (landmarkFetch->landmarks().count() < limit)
nextLandmarkButton->setEnabled(false);
else
nextLandmarkButton->setEnabled(true);
table->setUpdatesEnabled(false);
for(int i = table->rowCount() -1; i >= 0; --i) {
if (i %20 == 0)
qApp->processEvents();
table->removeRow(i);
}
landmarks = landmarkFetch->landmarks();
updateTable(landmarks);
table->setUpdatesEnabled(true);
} else {
QMessageBox::warning(this,"Warning", "Fetch Failed", QMessageBox::Ok, QMessageBox::NoButton);
}
updateRowLabels();
delete progress;
progress = new QProgressDialog (tr("Please wait..."),tr("Cancel"),0,0, this);
QObject::connect(progress,SIGNAL(canceled()), this, SLOT(cancel()));
break;
}
case QLandmarkAbstractRequest::CategoryFetchRequest: {
if (categoryFetch->error() == QLandmarkManager::NoError) {
if (currentCategoryOffset < limit)
prevCategoryButton->setEnabled(false);
else
prevCategoryButton->setEnabled(true);
if (categoryFetch->categories().count() < limit)
nextCategoryButton->setEnabled(false);
else
nextCategoryButton->setEnabled(true);
categoryTable->setUpdatesEnabled(false);
for (int i = categoryTable->rowCount() -1; i>=0; --i) {
if (i %20 ==0)
qApp->processEvents();
categoryTable->removeRow(i);
}
QList<QLandmarkCategory> cats;
cats = categoryFetch->categories();
updateCategoryTable(cats);
categoryTable->setUpdatesEnabled(true);
} else {
QMessageBox::warning(this, "Warning", "Category Fetch Failed", QMessageBox::Ok, QMessageBox::NoButton);
}
updateCategoryRowLabels();
if (tabWidget->currentIndex() == 1) {
//progress->hide();
delete progress;
progress = new QProgressDialog (tr("Please wait..."),tr("Cancel"),0,0, this);
QObject::connect(progress,SIGNAL(canceled()), this, SLOT(cancel()));
}
}
}
}
}
