void Fight::slot_animateFighting()
{
attalFightData dataFight;
if( !_attData->isEmpty() ) {
if( !_animatedUnit || !_animatedUnit->isMoving() ) {
dataFight = _attData->first();
processData( dataFight );
_attData->removeFirst();
}
if( _animatedUnit && _animatedUnit->isMoving() ) {
dataFight = _attData->first();
while(( _animatedUnit == dataFight.unit && dataFight.dataType == FIGHT_DATA_MOVE ) ) {
processData( dataFight );
_attData->removeFirst();
dataFight = _attData->first();
}
}
} else {
_animatedUnit = NULL;
}
checkTimer();
}
void DocumentLoader::dataReceived(Resource* resource,
const char* data,
size_t length) {
DCHECK(data);
DCHECK(length);
DCHECK_EQ(resource, m_mainResource);
DCHECK(!m_response.isNull());
DCHECK(!m_frame->page()->defersLoading());
if (m_inDataReceived) {
// If this function is reentered, defer processing of the additional data to
// the top-level invocation. Reentrant calls can occur because of web
// platform (mis-)features that require running a nested message loop:
// - alert(), confirm(), prompt()
// - Detach of plugin elements.
// - Synchronous XMLHTTPRequest
m_dataBuffer->append(data, length);
return;
}
AutoReset<bool> reentrancyProtector(&m_inDataReceived, true);
processData(data, length);
// Process data received in reentrant invocations. Note that the invocations
// of processData() may queue more data in reentrant invocations, so iterate
// until it's empty.
const char* segment;
size_t pos = 0;
while (size_t length = m_dataBuffer->getSomeData(segment, pos)) {
processData(segment, length);
pos += length;
}
// All data has been consumed, so flush the buffer.
m_dataBuffer->clear();
}
void SignalProcessor::input(double red, double green, double blue) {
qDebug() << "SignalProcessor: set Input" << red << green << blue;
processData(dataRedIn, dataRedOut, red);
processData(dataGreenIn, dataGreenOut, green);
processData(dataBlueIn, dataBlueOut, blue);
emit output(dataRedOut->last(), dataGreenOut->last(), dataBlueOut->last());
qDebug() << "SignalProcessor: output " << dataRedOut->last() << dataGreenOut->last() << dataBlueOut->last();
}
//***********************************************************
//* Process a <noteresource> node.
//***********************************************************
void ImportEnex::processResource(Resource &resource) {
bool atEnd = false;
resource.active = true;
while(!atEnd) {
if (reader->isStartElement()) {
QString name = reader->name().toString().toLower();
QUuid uuid;
QString g = uuid.createUuid().toString().replace("{","").replace("}","");
resource.guid = g;
if (name == "active") {
resource.active = booleanValue();
}
if (name == "mime") {
resource.mime = textValue();
}
if (name == "duration") {
resource.duration = shortValue();
}
if (name == "height") {
resource.height = shortValue();
}
if (name == "width") {
resource.width = shortValue();
}
if (name == "data") {
Data d;
resource.data = d;
processData("Data", resource.data);
}
if (name == "alternate-data") {
Data d;
resource.alternateData = d;
processData("AlternateData", resource.data);
}
if (name == "recognition-data") {
Data d;
resource.recognition = d;
processData("RecognitionData", resource.recognition);
}
if (name == "resource-attributes") {
ResourceAttributes ra;
resource.attributes = ra;
processResourceAttributes(resource.attributes);
}
}
reader->readNext();
QString endName = reader->name().toString().toLower();
if (endName == "resource" && reader->isEndElement())
atEnd = true;
}
}
void TcpSockServer::incomingConnection(int socketDescriptor)
{
qRegisterMetaType <Qlist>("Qlist");
// qDebug() << QString("Client %1 Comming").arg(socketDescriptor);
TcpConThread *thread = new TcpConThread(socketDescriptor, this);
// connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
connect(this,SIGNAL(sendKeySettingRequest(Device,RegOperation)),
thread,SLOT(sendKeySettingRequest(Device,RegOperation)));
connect(this,SIGNAL(grabWindow()),thread,SLOT(sendGrabWindowRequest()));
connect(thread,SIGNAL(processData(Qlist)),
this,SIGNAL(processData(Qlist)));
thread->start();
}
void SAXMzxmlHandler::endElement(const XML_Char *el)
{
if(isElement("peaks", el))
{
processData();
m_bInPeaks = false;
}
else if(isElement("precursorMz", el))
{
processData();
m_bInPrecursorMz = false;
}
else if(isElement("scan", el) && m_bInMsLevel2 == true)
{
// only add a spectrum without charge (which will lead
// to internal xtandem charge state guessing) if there
// were no values parsed from *both* "precursorCharge"
// or "possibleCharges"
if ( (m_precursorCharge == 0) && (m_viPossiblePrecursorCharges.size() == 0) ) {
// add spectrum, with precursorMz charge
pushSpectrum();
}
else {
// add the spectrum with the m_precursorCharge value
int originalPrecursorMZ = m_precursorCharge; // do other pushSpectrum calls change this?
pushSpectrum(m_precursorCharge);
// are there any multiple precursor charges from mzXML 3.1's
// possibleCharges?
if (m_viPossiblePrecursorCharges.size() > 0) {
size_t originalId = m_tId;
for (vector<int>::iterator i = m_viPossiblePrecursorCharges.begin();
i != m_viPossiblePrecursorCharges.end();
++i) {
int z = *i;
if (z != originalPrecursorMZ) { // no need to duplicate if already added
m_tId += 100000000;
pushSpectrum(z);
}
}
m_tId = originalId;
}
}
m_bInMsLevel2 = false;
}
}
int cDataMap::read_xml_file(string incdir)
{
xmlTextReaderPtr reader;
int ret;
string genre = incdir + "genre.xml" ;
string category = incdir + "category.xml" ;
// read categories and genre into ONE map. They don't share id's (Logic genre div 100 = category, genre is never full 100)
// categories
reader = xmlReaderForFile(category.c_str(), "iso-8859-1" , XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
while (ret == 1) {
processData(reader);
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
fprintf(stderr, "epgdata2vdr : failed to parse %s\n", category.c_str() );
return ret;
}
}
else {
fprintf(stderr, "Unable to open %s\n", category.c_str());
return -1;
}
// genres
reader = xmlReaderForFile(genre.c_str(), "iso-8859-1" , XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
while (ret == 1) {
processData(reader);
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
fprintf(stderr, "Failed to parse %s.\n", genre.c_str());
return ret;
}
}
else {
fprintf(stderr, "Unable to open %s\n", genre.c_str());
return -1;
}
return 0;
}
/*** FUNCTION CODE ***/
int main(int argc, char *argv[]) {
//Setup Signal handler and atexit functions
signal(SIGINT, INThandler); //Interrupts (calls INThandler) when Ctrl+c (?)
COM1 = open_serialport("/dev/ttyUSB0",500000); //Open USB port
Time_struct Curr_time; //Create time structure
Curr_time = get_time(); //Fill it with current time
char fname[26]; //Create space for filename
sprintf(fname, "%d-%d-%d-%d:%d:%d:%d.csv", Curr_time.year, Curr_time.month, Curr_time.day, Curr_time.hour, Curr_time.minute, Curr_time.second, Curr_time.msecond); //Create filename (date, time)
fp = fopen(fname,"w"); //Open file
struct sockaddr_in outsock;
int s_out_sensordata, slen = sizeof(struct sockaddr_in);
initClientSocket(IMU_PORT, &s_out_sensordata, OPC_IP, &outsock);
//initClientSocket(65100, &s_out_sensordata, "10.0.0.10", &outsock); //fakeclient
sensor_data data;
initBuffer();
while(running) {
data = receiveSensorData();
writeToBuffer(&data);
if (processData(&data))
sendSensorData(&data, s_out_sensordata, outsock, slen);
}
//At end by Ctrl+c
printf("Fin\n");
fclose(fp); //Close file
return 0;
}
void GrooveRequest::post()
{
QString cacheKey = generateCacheKey();
if (cacheKey.length()) {
qDebug() << Q_FUNC_INFO << "Possibly cached request";
QString cachePath = QDesktopServices::storageLocation(QDesktopServices::CacheLocation) + "/libgroove/cache/api/" + cacheKey;
QFile cacheFile(cachePath);
if (cacheFile.open(QIODevice::ReadOnly)) {
qDebug() << Q_FUNC_INFO << "Definitely cached request";
QByteArray response = cacheFile.readAll();
processData(response);
return;
}
}
m_request.setHeader(m_request.ContentTypeHeader, "application/json");
QJson::Serializer serializer;
qDebug() << Q_FUNC_INFO << "Posting to: " << m_request.url();
qDebug() << Q_FUNC_INFO << serializer.serialize(buildRequest());
QNetworkReply *reply = m_client->networkManager()->post(m_request, serializer.serialize(buildRequest()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SIGNAL(error(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(finished()), SLOT(onFinished()));
}
void processResData_ByRotID( const std::string& resName, ContainerType& data, RotamerLibrary& _RotLib )
{
// Sort the data to increase efficiency below
std::stable_sort( data.begin(), data.end(), sortPsi);
std::stable_sort( data.begin(), data.end(), sortPhi);
std::stable_sort( data.begin(), data.end(), sortRotID);
ContainerType subdata;
while( true )
{
if( data.size() > 0 && (subdata.size() == 0 || subdata[0].rotID.compare( data.back().rotID,0,4,0 )) )
{
subdata.push_back( data.back() );
data.erase(data.end()-1); // rob the end, not the start (ContainerType<> perfomance reasons!)
}
else
{
ASSERT( data.size() == (36*36), ParseException, "Assumption error!");
ASSERT( data[0].phi == -180.0 && data[0].psi == -180.0, ParseException, "Wrong phi/psi");
for( size_t j = 1; j < data.size(); j++ )
{
ASSERT( data[j].phi == (-180.0+(j/36)*10) && data[j].psi == (-180.0+(j%36)*10), ParseException, "Wrong phi/psi");
}
processData( resName, subdata, _RotLib, 40.0 ); // 40 degree tollerance delta from data[0]
subdata.clear();
if( data.size() == 0 )
{
return;
}
}
}
}
void NewSerialPort::read(std::vector<char>& aDataBuffer,
size_t aNumOfBytesToRead)
{
#if _WIN32
size_t numBytesRead = 0;
aDataBuffer.clear();
aDataBuffer.assign(aNumOfBytesToRead, '\0');
BOOL result = ReadFile(
m_serialPortHandle,
aDataBuffer.data(),
aNumOfBytesToRead,
reinterpret_cast<LPDWORD>(&numBytesRead),
NULL);
DWORD error = GetLastError();
if (!result && GetLastError() != ERROR_IO_PENDING)
{
throw unknown_error();
}
else if (numBytesRead > 0)
{
// For an accurate reading of how many bytes were actually read
aDataBuffer.resize(numBytesRead);
storeReadData(aDataBuffer);
processData();
}
#endif
}
void
WorkerTask::handleMsg(Msg *msg)
{
// flush any irrelevant messages
if (msg->getActivityId() != activityId)
return;
switch (msg->getCode()) {
case DfbProcess:
// perform a DFB/channelization
lock();
processData(msg);
unlock();
break;
case DATA_COLLECTION_COMPLETE:
// all channels are done, time to go
lock();
spectrometer->stopSpectrometry(activity);
activity = 0;
activityId = -1;
unlock();
break;
case STOP_DX_ACTIVITY:
case SHUTDOWN_DX:
case RESTART_DX:
lock();
stopActivity(msg);
unlock();
terminate();
break;
default:
Fatal(ERR_IMT);
break;
}
}
int main(void){
DDRC = 0x00;
uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
sei();
unsigned int c;
while(1){
c = uart_getc();
if(c & UART_NO_DATA){
/*
* NO UART DATA available
*/
}
else{
/*
* New Data is avialable at the port.
* check the frame for overrun errro
*/
if ( c & UART_FRAME_ERROR ){
/* Framing Error detected, i.e no stop bit detected */
uart_puts_P("UART Frame Error: ");
}
if ( c & UART_OVERRUN_ERROR ){
/*
*
* Overrun, a character already present in the UART UDR register was
*
* not read by the interrupt handler before the next character arrived,
* one or more received characters have been dropped
*
*
*/
uart_puts_P("UART Overrun Error: ");
}
if ( c & UART_BUFFER_OVERFLOW ){
/*
*
* We are not reading the receive buffer fast enough,
*
* one or more received character have been dropped
*
*/
uart_puts_P("Buffer overflow error: ");
}
processData(c);
// PORTC = c;
}
}
return 0;
}
void AudioCapture::run()
{
m_userStop = false;
while (!m_userStop)
{
m_mutex.lock();
if (m_pause == false && m_captureSize != 0)
{
if (readAudio(m_captureSize) == true)
{
processData();
}
else
{
//qDebug() << "Error reading data from audio source";
usleep(5000);
}
}
else
usleep(15000);
m_mutex.unlock();
}
}
static WMPropList *processSubmenu(WEditMenu * menu)
{
WEditMenuItem *item;
WMPropList *pmenu;
WMPropList *pl;
char *s;
int i;
s = WGetEditMenuTitle(menu);
pl = WMCreatePLString(s);
pmenu = WMCreatePLArray(pl, NULL);
i = 0;
while ((item = WGetEditMenuItem(menu, i++))) {
WEditMenu *submenu;
s = WGetEditMenuItemTitle(item);
submenu = WGetEditMenuSubmenu(item);
if (submenu) {
pl = processSubmenu(submenu);
} else {
pl = processData(s, WGetEditMenuItemData(item));
}
if (!pl)
continue;
WMAddToPLArray(pmenu, pl);
}
return pmenu;
}
bool ValveRuntimeBox::setValve(int)
{
Q_ASSERT(m_valve.outputPort()->state().hasData());
m_valveOpen = m_valve.data().data()[0] != 0;
m_hasValve = true;
return processData();
}
void shakeData::loadSMC(string filename)
{
file=filename;
ifstream input(ofToDataPath(file).c_str());
string buffer;
sampFreq=200.;
bool tagOpen=false;
int pipeCount=0;
vector<double> val;
getline(input, buffer);
while(buffer.length()&&(buffer[0]=='|'||pipeCount<4)){
if(buffer.length()&&buffer[0]=='|') pipeCount++;
getline(input, buffer);
}
while (input.peek()!=EOF) {
getline(input, buffer);
if(buffer.length()%10==0){
for(int i=0; i<buffer.length()/10; i++){
string num(buffer.begin()+10*i,buffer.begin()+10*i+10);
//uData.push_back(dataPoint(ofToFloat(num),1/sampFreq));
val.push_back(ofToFloat(num));
}
}
}
input.close();
for(unsigned int i=0; i<val.size(); i++){
uData.push_back(dataPoint(val[i],1/sampFreq));
}
processData();
}
void shakeData::loadCOSMOS(string filename)
{
file=filename;
ifstream input(ofToDataPath(file).c_str());
string buffer;
vector<double> val;
int burn=45;
while(burn--){
getline(input, buffer);
}
getline(input, buffer);
int numPoints=ofToInt(buffer.substr(0,buffer.find_first_of(' ',4)));
sampFreq=1/ofToFloat(buffer.substr(47,4));
string format=buffer.substr(buffer.find_last_of("(")+1,buffer.find_last_of(")")-(buffer.find_last_of("(")+1));
cout <<numPoints << " of data, at " << sampFreq << " intervals in " << format << endl;
vector<string> spl=ofSplitString(format,"f.");
int pointsPerLine=ofToInt(spl[0]);
int space=ofToInt(spl[1]);
while(val.size()<numPoints){
getline(input, buffer);
for(unsigned int i=0; i<pointsPerLine&&val.size()<numPoints; i++){
val.push_back(ofToFloat(buffer.substr(i*space,space)));
}
}
for(unsigned int i=0; i<val.size(); i++){
uData.push_back(dataPoint(val[i],1/sampFreq));
}
input.close();
processData();
}
void MJPEGImageGrabber::onReadyRead()
{
// qDebug() << "got ready read";
m_imageData.append(m_reply->readAll());
// qDebug() << "number of bytes in imageData" << m_imageData.size();
QByteArray marker(streamSperator, strlen(streamSperator));
// qDebug() << "Marker " << marker;
if (!m_imageStarted) {
int index = m_imageData.indexOf(marker);
if (index < 0) { // current data doesn't have a image start
// qDebug() << "not started yet, leaving... looked for marker";
m_imageData.clear();
return;
}
m_imageStarted = true; //started
m_imageData = m_imageData.mid(index+marker.length()); // discard data before the start
}
int index = m_imageData.indexOf(marker);
if (index < 0) { // no end yet
// qDebug() << "frame started but no end yet, leaving...";
return;
}
// end reached, get the frame
// qDebug() << "one frame complete, process it";
QByteArray fullFrame = m_imageData.left(index);
Q_EMIT processData(fullFrame);
m_imageStarted = false;
m_imageData = m_imageData.mid(index+marker.length()); // discard data upto the extracted frame
}
void VideoDecoder::update() {
if (getTimeToNextFrame() > 0)
return;
processData();
copyData();
}
void KviHttpRequest::slotSocketReadDataReady()
{
KVI_ASSERT(m_p->pSocket);
int iBytes = m_p->pSocket->bytesAvailable();
if(iBytes <= 0)
{
// assume connection closed ?
slotSocketDisconnected();
return;
}
// FIXME: Avoid double-buffering here!
KviDataBuffer oBuffer(iBytes);
int iRead = m_p->pSocket->read((char *)(oBuffer.data()),iBytes);
if(iRead < iBytes)
{
// hum.... what here ?
if(iRead < 1)
{
slotSocketDisconnected();
return;
}
// FIXME
// well... otherwise just wait.
// FIXME ?
oBuffer.resize(iRead);
}
processData(&oBuffer);
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindow)
{
ui->setupUi(this);
/*connect(&m_tm, SIGNAL(timeout()), this, SLOT(processData()));
m_tm.setInterval(1);
m_tm.start();*/
QTimer *tm = new QTimer(this);
connect(tm, SIGNAL(timeout()), this, SLOT(draw()));
tm->setInterval(1000 / 60);
tm->start();
m_udp.bind(9999);
connect(&m_udp, SIGNAL(readyRead()), this, SLOT(processData()));
ui->visWorld->stat = 0;
ui->visWorld->pdaData = &m_pdaData;
ui->visWorld2->stat = 1;
ui->visWorld2->pdaData = &m_pdaData;
ui->visScreen->pdaData = &m_pdaData;
m_pdaData.sphereEnabled = 0;
ui->widgetSensors->setVisible(true);
ui->widgetSpheres->setVisible(false);
}
void BodyStreamBuffer::didGetReadable()
{
if (!m_reader)
return;
if (!m_streamNeedsMore) {
// Perform zero-length read to call close()/error() early.
size_t readSize;
WebDataConsumerHandle::Result result = m_reader->read(nullptr, 0, WebDataConsumerHandle::FlagNone, &readSize);
switch (result) {
case WebDataConsumerHandle::Ok:
case WebDataConsumerHandle::ShouldWait:
return;
case WebDataConsumerHandle::Done:
close();
return;
case WebDataConsumerHandle::Busy:
case WebDataConsumerHandle::ResourceExhausted:
case WebDataConsumerHandle::UnexpectedError:
error();
return;
}
return;
}
processData();
}
/**
* It processing incoming data by the radio or serial connection. This function
* has to be continously called to keep the node running. This function also
* adds a delay which is specified as 100ms per unit. Therefore 1000 = 100 sec
* @param countdown delay added to this function
*/
void awaitData(int countdown) {
uint8_t rx_len;
//Clear buffer
data_temp[0] = '\0';
RFM69_setMode(RFM69_MODE_RX);
while(countdown > 0) {
// Check rx buffer
if(RFM69_checkRx() == 1) {
RFM69_recv(data_temp, &rx_len);
data_temp[rx_len - 1] = '\0';
#ifdef DEBUG
//rssi = RFM69_lastRssi();
printf("rx: %s\r\n",data_temp);
//printf("RSSI: %d\r\n, rssi");
#endif
processData(rx_len);
}
#ifdef SERIAL_IN
// Check tx buffer
checkTxBuffer();
#endif
countdown--;
mrtDelay(100);
}
}
void Server::readyRead()
{
QTcpSocket * socket = static_cast<QTcpSocket *>(sender());
QByteArray * buffer = _buffers.value(socket);
qint32 size = *_sizes.value(socket);
while(socket->bytesAvailable() > 0)
{
buffer->append(socket->readAll());
// While can process data, process it
while ((buffer->count() >= 4 && size == 0) || (buffer->count() >= size && size > 0))
{
// If size of data has received completely, then store it on global variable
if (buffer->count() >= 4 && size == 0)
{
size = arrayToInt(buffer->mid(0, 4));
buffer->remove(0, 4);
}
// If data has received completely
if (buffer->count() >= size && size > 0)
{
QByteArray data = buffer->mid(0, size);
buffer->remove(0, size);
size = 0;
processData(data, socket);
}
}
}
}
// renyang - 把接收到的資料放到streamBuffer中
void Receiver::putData(char *buffer, int len)
{
#ifdef REN_DEBUG
qWarning(QString("Receiver::putData(char *buffer, int %1)").arg(len));
#endif
// renyang - 應該是要把音訊檔存到檔案中吧
if (outFile)
{
// renyang - 把接收到的資料放到outFile中
fwrite(buffer, 1, len, outFile);
fflush(outFile);
}
// renyang - 若剩下的buffer(MAXBUFSIZE - len)小於streamLen，則表示空間不夠, 出現錯誤啦當有資料送過來, 但是長度確沒有大於0，表示對方出現錯誤或是離開
// renyang - 也可以說streamLen+len > MAXBUFSIZE則表示目前在記憶體中的資料加上新的資料比最大長度還大
// renyang - streamLen可以看成MAXBUFSIZE目前使用到哪裡的index
if (streamLen > (MAXBUFSIZE - len))
{
qWarning("Warning: receiver buffer overloaded.");
// renyang - 把實際的資料刪成剛好可以放到buffer的大小
len = MAXBUFSIZE - streamLen;
}
// renyang - 把收到的資料加到streamBuffer的後面, streamLen是表示目前的stream是用到哪裡
memcpy(streamBuffer + streamLen, buffer, len);
// renyang - 增加streamLen
streamLen += len;
// renyang - 資料完成放到streamBuffer中啦
if (sync == STREAM_READ_DATA)
{
sync = STREAM_OK;
processData();
}
}
void Fight::socketFightEnd()
{
attalFightData dataFight;
uchar result = _socket->readChar();
// process all pending fight data before end of fight
while( !_attData->isEmpty() ) {
dataFight = _attData->first();
processData( dataFight );
_attData->removeFirst();
}
fightEnd( result );
/*
dataFight.result = _socket->readChar();
dataFight.dataType = FIGHT_DATA_END;
AttalSettings::FightSettings fsettings = AttalSettings::getInstance()->getFightSettings();
if( fsettings.isAnimationEnabled ) {
_attData->append(dataFight);
checkTimer();
} else {
fightEnd( dataFight.result );
}
*/
}
void SerialServer::processTransfer(QByteArray& header)
{
QDataStream headerStream(&header, QIODevice::ReadOnly);
quint16 startWord;
quint16 packetCount;
headerStream >> startWord;
headerStream >> packetCount;
if(startWord != SERIAL_START)
return;
qWarning("Got start...");
qWarning("packetcount=%d", packetCount);
QByteArray compressedData;
for(quint16 i = 0;i < packetCount;i++) {
QByteArray data;
if(!readPacket(&data))
return;
compressedData += data;
}
QByteArray data = qUncompress(compressedData);
compressedData.clear();
compressedData.squeeze();
processData(data);
}
void CYSFRX::samples(const q15_t* samples, uint8_t length)
{
for (uint16_t i = 0U; i < length; i++) {
bool bit = samples[i] < 0;
if (bit != m_prev) {
if (m_pll < (PLLMAX / 2U))
m_pll += INC;
else
m_pll -= INC;
}
m_prev = bit;
m_pll += PLLINC;
if (m_pll >= PLLMAX) {
m_pll -= PLLMAX;
if (m_state == YSFRXS_NONE)
processNone(samples[i]);
else
processData(samples[i]);
}
}
}
ReportManager::ReportManager(_structs * data, QWidget *parent) :
QDialog(parent),
ui(new Ui::ReportManager)
{
processSwitch = 0;
connect(&socketConn, SIGNAL(dataReady(QString)), this, SLOT(processData(QString)));
ui->setupUi(this);
for(int i = 1; i <= 12; i++ )
{
ui->monthSelector->addItem(QString::number(i));
}
// Build list of years
QDate now = QDate::currentDate();
int year = now.year();
QStringList years;
for(int i =0; i < 5; i++)
{
years.append(QString::number(year-i));
}
// Add to combo
ui->yearSelector->addItems(years);
dataStructs = data;
ui->startDate->setDate(QDate::currentDate().addDays(-7));
ui->endDate->setDate(QDate::currentDate());
}
