void AnnotationDialog::KDateEdit::showPopup()
{
if (mReadOnly)
return;
QRect desk = KGlobalSettings::desktopGeometry(this);
QPoint popupPoint = mapToGlobal( QPoint( 0,0 ) );
if ( popupPoint.x() < desk.left() ) popupPoint.setX( desk.x() );
int dateFrameHeight = mDateFrame->sizeHint().height();
if ( popupPoint.y() + height() + dateFrameHeight > desk.bottom() ) {
popupPoint.setY( popupPoint.y() - dateFrameHeight );
} else {
popupPoint.setY( popupPoint.y() + height() );
}
mDateFrame->move( popupPoint );
QDate date;
readDate(date, 0);
if (date.isValid()) {
mDatePicker->setDate( date );
} else {
mDatePicker->setDate( defaultValue );
}
mDateFrame->show();
}
Date PHN_Sim::getDate() {
Date date;
char resp[40];
char* args[1];
if (sendATCommand("AT+CCLK?", resp, 40) && getSimTextArgs(resp, args, 1) == 1) {
date = readDate(args[0]);
}
return date;
}
bool UtlXMLStream::readArrayElement(UtlDate& myValue) {
skipBlanks( getInputStream() );
if (!readBeginOfArrayElement("date"))
return false;
struct tm tmValue;
if (!readDate( getInputStream() , tmValue))
return false;
myValue=UtlDate( tmValue.tm_year, tmValue.tm_mon, tmValue.tm_mday, 0, 0, 0);
if (!readEndOfArrayElement())
return false;
return true;
}
int realTimeClock_t::readByte (unsigned short port) {
___CBTPUSH;
int result = -1;
if (port == 0x71) {
if (m_selected < STATUS) {
readDate ();
switch (m_selected) {
case SECONDS: result = m_date->tm_sec; break;
case MINUTES: result = m_date->tm_min; break;
case HOURS:
result = m_date->tm_hour;
if ((m_status[1] & F_24_HOUR_MODE) == 0) {
if (result > 0) {
if (result > 12) {
result = result - 12 | 0x80;
} else if (result == 12) {
result |= 0x80;
}
} else {
result = 12;
}
}
break;
case WEEKDAY: result = m_date->tm_wday; break;
case DAY_OF_MONTH: result = m_date->tm_mday; break;
case MONTH: result = m_date->tm_mon + 1; break;
case YEAR: result = m_date->tm_year % 100; break;
}
if ((m_status[1] & F_BINARY_FORMAT) == 0) {
if (result > 0x7F) {
result &= 0x7F;
result = getBcdValue (result);
result |= 0x80;
} else {
result = getBcdValue (result);
}
}
} else if (m_selected < STATUS + 6) {
result = m_status[m_selected - STATUS];
}
}
m_selected = DEFAULT;
___CBTPOP;
return result;
}
void AnnotationDialog::KDateEdit::lineEnterPressed()
{
if ( !mTextChanged )
return;
QDate date;
QDate end;
if (readDate(date, &end) && (mHandleInvalid || date.isValid()) && validate(date))
{
// Update the edit. This is needed if the user has entered a
// word rather than the actual date.
setDate(date);
emit(dateChanged(date));
emit dateChanged( DB::ImageDate( QDateTime(date), QDateTime(end) ) );
}
else {
// Invalid or unacceptable date - revert to previous value
setDate(value);
emit invalidDateEntered();
}
}
bool UtlXMLStream::readAttribute(std::string& sName, UtlDate& myValue) {
skipBlanks( getInputStream() );
if (!readName(sName))
return false;
if (!readBeginningOfAttribute())
return false;
struct tm tmValue;
if (!readDate( getInputStream() , tmValue))
return false;
myValue=UtlDate( tmValue.tm_year, tmValue.tm_mon, tmValue.tm_mday, 0, 0, 0);
if (!readEndOfAttribute())
return false;
return true;
}
uint32_t Node::decode(const std::vector<uint8_t>& buffer, uint32_t offset)
{
uint32_t originalOffset = offset;
if (buffer.size() - offset < 1)
{
return 0;
}
marker = *reinterpret_cast<const Marker*>(buffer.data() + offset);
offset += 1;
uint32_t ret = 0;
switch (marker)
{
case Marker::Number: ret = readNumber(buffer, offset, doubleValue); break;
case Marker::Boolean: ret = readBoolean(buffer, offset, boolValue); break;
case Marker::String: ret = readString(buffer, offset, stringValue); break;
case Marker::Object: ret = readObject(buffer, offset, mapValue); break;
case Marker::Null: /* Null */; break;
case Marker::Undefined: /* Undefined */; break;
case Marker::ECMAArray: ret = readECMAArray(buffer, offset, mapValue); break;
case Marker::ObjectEnd: break; // should not happen
case Marker::StrictArray: ret = readStrictArray(buffer, offset, vectorValue); break;
case Marker::Date: ret = readDate(buffer, offset, dateValue); break;
case Marker::LongString: ret = readLongString(buffer, offset, stringValue); break;
case Marker::XMLDocument: ret = readXMLDocument(buffer, offset, stringValue); break;
case Marker::TypedObject: ret = readTypedObject(buffer, offset); break;
case Marker::SwitchToAMF3: ret = readSwitchToAMF3(buffer, offset); break;
default: return 0;
}
offset += ret;
return offset - originalOffset;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NIImporter_DlrNavteq::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether the option is set (properly)
if (!oc.isSet("dlr-navteq-prefix")) {
return;
}
time_t csTime;
time(&csTime);
// parse file(s)
LineReader lr;
// load nodes
std::map<std::string, PositionVector> myGeoms;
PROGRESS_BEGIN_MESSAGE("Loading nodes");
std::string file = oc.getString("dlr-navteq-prefix") + "_nodes_unsplitted.txt";
NodesHandler handler1(nb.getNodeCont(), file, myGeoms);
if (!lr.setFile(file)) {
throw ProcessError("The file '" + file + "' could not be opened.");
}
lr.readAll(handler1);
PROGRESS_DONE_MESSAGE();
// load street names if given and wished
std::map<std::string, std::string> streetNames; // nameID : name
if (oc.getBool("output.street-names")) {
file = oc.getString("dlr-navteq-prefix") + "_names.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading Street Names");
NamesHandler handler4(file, streetNames);
lr.readAll(handler4);
PROGRESS_DONE_MESSAGE();
} else {
WRITE_WARNING("Output will not contain street names because the file '" + file + "' was not found");
}
}
// load edges
PROGRESS_BEGIN_MESSAGE("Loading edges");
file = oc.getString("dlr-navteq-prefix") + "_links_unsplitted.txt";
// parse the file
EdgesHandler handler2(nb.getNodeCont(), nb.getEdgeCont(), nb.getTypeCont(), file, myGeoms, streetNames);
if (!lr.setFile(file)) {
throw ProcessError("The file '" + file + "' could not be opened.");
}
lr.readAll(handler2);
nb.getEdgeCont().recheckLaneSpread();
PROGRESS_DONE_MESSAGE();
// load traffic lights if given
file = oc.getString("dlr-navteq-prefix") + "_traffic_signals.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading traffic lights");
TrafficlightsHandler handler3(nb.getNodeCont(), nb.getTLLogicCont(), nb.getEdgeCont(), file);
lr.readAll(handler3);
PROGRESS_DONE_MESSAGE();
}
// load prohibited manoeuvres if given
file = oc.getString("dlr-navteq-prefix") + "_prohibited_manoeuvres.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading prohibited manoeuvres");
ProhibitionHandler handler6(nb.getEdgeCont(), file, csTime);
lr.readAll(handler6);
PROGRESS_DONE_MESSAGE();
}
// load connected lanes if given
file = oc.getString("dlr-navteq-prefix") + "_connected_lanes.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading connected lanes");
ConnectedLanesHandler handler7(nb.getEdgeCont());
lr.readAll(handler7);
PROGRESS_DONE_MESSAGE();
}
// load time restrictions if given
file = oc.getString("dlr-navteq-prefix") + "_links_timerestrictions.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading time restrictions");
if (!oc.isDefault("construction-date")) {
csTime = readDate(oc.getString("construction-date"));
}
TimeRestrictionsHandler handler5(nb.getEdgeCont(), nb.getDistrictCont(), csTime);
lr.readAll(handler5);
handler5.printSummary();
PROGRESS_DONE_MESSAGE();
}
}
QDate KLocale::readDate(const QString &intstr, const QString &fmt, bool *ok) const
{
return d->readDate(intstr, fmt, ok);
}
QDate KLocale::readDate(const QString &intstr, ReadDateFlags flags, bool *ok) const
{
return d->readDate(intstr, flags, ok);
}
SimMessage PHN_Sim::getMessage(int messageIndex) {
// Put into text mode
sendATCommand("AT+CMGF=1");
// Set up a command to read the message
char command[13] = "AT+CMGR=";
char resp[400];
char *args[5];
itoa(messageIndex+1, command+8, 10);
sendATCommand(command, resp, 400);
// Allocate the message to return
SimMessage message;
// Split the response arguments
// If this fails, message will be left all-0
message.valid = getSimTextArgs(resp, args, 5) == 5;
if (message.valid) {
// Parse the text arguments
message.index = messageIndex;
message.read = !strcmp(args[0], "REC READ");
strcpy(message.sender.number, args[1]);
strcpy(message.sender.text, args[2]);
message.date = readDate(args[3]);
// If the entire message consists of HEX characters, convert to ASCII
char* msgText = args[4];
int msgLen = strlen(msgText);
bool allHex = (msgLen >= 2);
for (int i = 0; (i < msgLen) && allHex; i++) {
allHex = (msgText[i] >= 48) && (msgText[i] <= 70);
}
if (allHex) {
unsigned char data_ctr = 1;
char *buff = message.text-1;
for (int i = 0; i < msgLen; i++) {
// Skip every 2 first bytes
if (!(i & 0x2)) continue;
// Read the new byte
char c = msgText[i];
// Start of a new byte, increment and set to an initial 0x00
data_ctr++;
if (!(data_ctr & 0x1)) {
*(++buff) = 0x00;
}
// Convert the character into HEX, put it into the buffer
*buff <<= 4;
if (c & 0x40) {
c -= ('A' - '0') - 10;
}
*buff |= (c - '0') & 0xF;
// For 'weird' unreadable ASCII characters, replace with ???
if ((data_ctr & 0x1) && ((*buff >= 127) || (*buff <= 8))) {
*buff = '?';
}
}
// Make sure we null-terminate
*(++buff) = 0;
} else {
// Just copy it over
strcpy(message.text, msgText);
}
}
return message;
}
int main() {
// global interupt enable
sei();
// Start I2C
i2c_init();
// Start UART
//UART_init();
// start ADC
ADC_init();
// termistor on ADC channel 2
ADC_channel(ADCCHANNEL);
portConfig();
// timer0 aprox. get data from RTC
// timer1 for update 7 segment
timer0start();
// aprox. 4x per second
timer1start();
// read Epprom
readDataFromEeprom();
// read time from RTC
getTime();
while(1) {
// if set is set for modify values PB1
if (debounce(&PINB, PB1)) {
changeStateCounter = 0;
if (set) {
timer1stop();
switch (show) {
case show_time:
if(set == set_second) {
minute++;
if (minute > 59) {
minute = 0;
}
write(minute, minute_RTC);
}
if(set == set_first) {
hour++;
if (hour > 23) {
hour = 0;
}
write(hour, hour_RTC);
}
break;
case show_switch:
break;
case show_date:
if(set == set_first) {
day++;
if (day > 31) {
day = 1;
}
write(day, day_RTC);
}
if(set == set_second) {
month++;
if (month > 12) {
month = 1;
}
write(month, month_RTC);
}
break;
case show_year:
if(set == set_both) {
year++;
if (year > 99) {
year = 0;
}
write(year, year_RTC);
}
break;
case show_onTime1:
if(set == set_first) {
on[0]++;
if (on[0] > 23) {
on[0] = 0;
}
eeprom_write_byte ((uint8_t*)0, on[0]);
}
if(set == set_second) {
on[1]++;
if (on[1] > 59) {
on[1] = 0;
}
eeprom_write_byte ((uint8_t*)1, on[1]);
}
if(set == set_both) {
if (dayStatus[0] == d_day) {
dayStatus[0] = d_night;
} else if (dayStatus[0] == d_night) {
dayStatus[0] = d_off;
} else {
dayStatus[0] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 1, (uint8_t)dayStatus[0]);
}
break;
case show_onTime2:
if(set == set_first) {
on[2]++;
if (on[2] > 23) {
on[2] = 0;
}
eeprom_write_byte ((uint8_t*)2, on[2]);
}
if(set == set_second) {
on[3]++;
if (on[3] > 59) {
on[3] = 0;
}
eeprom_write_byte ((uint8_t*)3, on[3]);
}
if(set == set_both) {
if (dayStatus[1] == d_day) {
dayStatus[1] = d_night;
} else if (dayStatus[1] == d_night) {
dayStatus[1] = d_off;
} else {
dayStatus[1] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 2, (uint8_t)dayStatus[1]);
}
break;
case show_onTime3:
if(set == set_first) {
on[4]++;
if (on[4] > 23) {
on[4] = 0;
}
eeprom_write_byte ((uint8_t*)4, on[4]);
}
if(set == set_second) {
on[5]++;
if (on[5] > 59) {
on[5] = 0;
}
eeprom_write_byte ((uint8_t*)5, on[5]);
}
if(set == set_both) {
if (dayStatus[2] == d_day) {
dayStatus[2] = d_night;
} else if (dayStatus[2] == d_night) {
dayStatus[2] = d_off;
} else {
dayStatus[2] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 3, (uint8_t)dayStatus[2]);
}
break;
case show_onTime4:
if(set == set_first) {
on[6]++;
if (on[6] > 23) {
on[6] = 0;
}
eeprom_write_byte ((uint8_t*)6, on[6]);
}
if(set == set_second) {
on[7]++;
if (on[7] > 59) {
on[7] = 0;
}
eeprom_write_byte ((uint8_t*)7, on[7]);
}
if(set == set_both) {
if (dayStatus[3] == d_day) {
dayStatus[3] = d_night;
} else if (dayStatus[3] == d_night) {
dayStatus[3] = d_off;
} else {
dayStatus[3] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 4, (uint8_t)dayStatus[3]);
}
break;
case show_onTime5:
if(set == set_first) {
on[8]++;
if (on[8] > 23) {
on[8] = 0;
}
eeprom_write_byte ((uint8_t*)8, on[8]);
}
if(set == set_second) {
on[9]++;
if (on[9] > 59) {
on[9] = 0;
}
eeprom_write_byte ((uint8_t*)9, on[9]);
}
if(set == set_both) {
if (dayStatus[4] == d_day) {
dayStatus[4] = d_night;
} else if (dayStatus[4] == d_night) {
dayStatus[4] = d_off;
} else {
dayStatus[4] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 5, (uint8_t)dayStatus[4]);
}
break;
case show_onTime6:
if(set == set_first) {
on[10]++;
if (on[10] > 23) {
on[10] = 0;
}
eeprom_write_byte ((uint8_t*)10, on[10]);
}
if(set == set_second) {
on[11]++;
if (on[11] > 59) {
on[11] = 0;
}
eeprom_write_byte ((uint8_t*)11, on[11]);
}
if(set == set_both) {
if (dayStatus[5] == d_day) {
dayStatus[5] = d_night;
} else if (dayStatus[5] == d_night) {
dayStatus[5] = d_off;
} else {
dayStatus[5] = d_day;
}
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS + 6, (uint8_t)dayStatus[5]);
}
break;
case show_co2on:
if(set == set_first) {
co2[0]++;
if (co2[0] > 23) {
co2[0] = 0;
}
eeprom_write_byte ((uint8_t*)12, co2[0]);
}
if(set == set_second) {
co2[1]++;
if (co2[1] > 59) {
co2[1] = 0;
}
eeprom_write_byte ((uint8_t*)13, co2[1]);
}
break;
case show_co2off:
if(set == set_first) {
co2[2]++;
if (co2[2] > 23) {
co2[2] = 0;
}
eeprom_write_byte ((uint8_t*)14, co2[2]);
}
if(set == set_second) {
co2[3]++;
if (co2[3] > 59) {
co2[3] = 0;
}
eeprom_write_byte ((uint8_t*)15, co2[3]);
}
break;
}
timer1start();
} else {
// this is place for change display
// daytime, date, yer, set dates, etc.
show++;
if (show == show_end) {
show = show_time;
}
}
}
// button for change position for update PC3
if (debounce(&PINC, PC3)) {
changeStateCounter = 0;
switch (show) {
case show_time:
case show_date:
case show_co2on:
case show_co2off:
set++;
if (set == set_both) {
set = set_none;
}
readDate();
break;
case show_onTime1:
case show_onTime2:
case show_onTime3:
case show_onTime4:
case show_onTime5:
case show_onTime6:
set++;
if (set == set_end) {
set = set_none;
}
break;
case show_year:
if (set == set_both) {
set = set_none;
} else {
set = set_both;
}
readYear();
break;
case show_switch:
switchStatus++;
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS, switchStatus);
if(switchStatus == switch_end) {
switchStatus = switch_off;
}
break;
}
}
if (debounce(&PINB, PB0)) {
changeStateCounter = 0;
show = show_switch;
switchStatus++;
eeprom_write_byte ((uint8_t*)STATUS_EEPROM_POS, switchStatus);
if (switchStatus == switch_end) {
switchStatus = switch_off;
}
}
//val = getTemperature();
//sprintf (str, "value: %d.", val);
//UART_puts(str);
//UART_puts("\n");
//_delay_ms(500);
}
return 0;
}
bool AnnotationDialog::KDateEdit::inputIsValid() const
{
QDate date;
return readDate(date, 0) && date.isValid();
}
QDate AnnotationDialog::KDateEdit::date() const
{
QDate dt;
readDate(dt, 0);
return dt;
}
string psoCat::odbcKeyToStr( uint32_t length )
{
psoKeyFieldDefinition * keyODBC;
int numKeys, i;
string outStr;
keyODBC = (psoKeyFieldDefinition *) keyDef;
numKeys = keyDefLength / sizeof(psoKeyFieldDefinition);
psoaGetKeyOffsets( keyODBC, numKeys, keyOffsets );
for ( i = 0; i < numKeys; ++i ) {
string s;
switch( keyODBC[i].type ) {
case PSO_KEY_INTEGER:
s = readInt32( &key[keyOffsets[i]] );
break;
case PSO_KEY_BIGINT:
s = readInt64( &key[keyOffsets[i]] );
break;
case PSO_KEY_BINARY:
readBinary( s,
keyODBC[i].length,
&key[keyOffsets[i]] );
break;
case PSO_KEY_CHAR:
readString( s,
keyODBC[i].length,
&key[keyOffsets[i]] );
break;
case PSO_KEY_VARCHAR:
case PSO_KEY_LONGVARCHAR:
readString( s,
length - keyOffsets[i],
&key[keyOffsets[i]] );
break;
case PSO_KEY_VARBINARY:
case PSO_KEY_LONGVARBINARY:
readBinary( s,
length - keyOffsets[i],
&key[keyOffsets[i]] );
break;
case PSO_KEY_DATE:
s = readDate( &key[keyOffsets[i]] );
break;
case PSO_KEY_TIME:
s = readTime( &key[keyOffsets[i]] );
break;
case PSO_KEY_TIMESTAMP:
s = readTimeStamp( &key[keyOffsets[i]] );
break;
}
outStr += s;
if ( i < numKeys-1) outStr += ", ";
}
return outStr;
}
string psoCat::odbcFieldToStr( uint32_t length )
{
psoFieldDefinition * fieldODBC;
int numFields, i;
string outStr;
fieldODBC = (psoFieldDefinition *) fieldDef;
numFields = fieldDefLength / sizeof(psoFieldDefinition);
psoaGetFieldOffsets( fieldODBC, numFields, fieldOffsets );
for ( i = 0; i < numFields; ++i ) {
string s;
switch( fieldODBC[i].type ) {
case PSO_TINYINT:
s = readInt8( &buffer[fieldOffsets[i]] );
break;
case PSO_SMALLINT:
s = readInt16( &buffer[fieldOffsets[i]] );
break;
case PSO_INTEGER:
s = readInt32( &buffer[fieldOffsets[i]] );
break;
case PSO_BIGINT:
s = readInt64( &buffer[fieldOffsets[i]] );
break;
case PSO_BINARY:
readBinary( s,
fieldODBC[i].vals.length,
&buffer[fieldOffsets[i]] );
break;
case PSO_CHAR:
readString( s,
fieldODBC[i].vals.length,
&buffer[fieldOffsets[i]] );
break;
case PSO_NUMERIC:
s = readDecimal( fieldODBC[i].vals.decimal.precision,
fieldODBC[i].vals.decimal.scale,
&buffer[fieldOffsets[i]] );
break;
case PSO_VARCHAR:
case PSO_LONGVARCHAR:
readString( s,
length - fieldOffsets[i],
&buffer[fieldOffsets[i]] );
break;
case PSO_VARBINARY:
case PSO_LONGVARBINARY:
readBinary( s,
length - fieldOffsets[i],
&buffer[fieldOffsets[i]] );
break;
case PSO_REAL:
s = readFloat32( &buffer[fieldOffsets[i]] );
break;
case PSO_DOUBLE:
s = readFloat64( &buffer[fieldOffsets[i]] );
break;
case PSO_DATE:
s = readDate( &buffer[fieldOffsets[i]] );
break;
case PSO_TIME:
s = readTime( &buffer[fieldOffsets[i]] );
break;
case PSO_TIMESTAMP:
s = readTimeStamp( &buffer[fieldOffsets[i]] );
break;
}
outStr += s;
if ( i < numFields-1) outStr += ", ";
}
return outStr;
}
