void MobileAgent::flushLog (ElapsedTime p_time, bool bmissflight)
{
m_iPreState = state;
state = Death;
writeLogEntry (p_time, false);
m_logEntry.setExitTime (p_time);
long trackCount = m_logEntry.getCurrentCount();
MobEventStruct *log = NULL;
m_logEntry.getLog (log);
// write first member of group
m_logEntry.setEventList (log, trackCount);
delete [] log;
log = NULL;
assert( m_pTerm );
m_pTerm->paxLog->updateItem (m_logEntry, m_logEntry.getIndex());
m_pGroupInfo->FlushLogforFollower( p_time );
m_logEntry.clearLog();
}
void kweather::refresh(TQString stationID)
{
kdDebug(12004) << "refresh " << stationID << endl;
if( stationID == reportLocation)
{
showWeather();
writeLogEntry();
}
}
//-------------------------------------------------------------------------------------------------------
bool GlesRenderer::initialize(const Renderer::Parameters& parameters)
{
parameters_ = parameters;
writeLogEntry("initializing OpenGL ES renderer");
if(!capabilities_.createCompatibleContext(parameters_, effectsList_))
{
writeLogEntry("error: could not create compatible OpenGL ES 2.0 context");
return false;
}
// initialize helpers
if(!initializeHelpers())
return false;
// prepare OpenGL ES
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
CHECK_GLES_ERROR("GlesRenderer::initialize: glEnable");
return true;
}
void TextMessageDlg::newMsg(const TextMessage& msg, bool store)
{
switch(msg.nMsgType)
{
case MSGTYPE_USER :
{
QString line = ui.historyTextEdit->addTextMessage(msg);
ui.newmsgLabel->setText(tr("New message"));
QString folder = ttSettings->value(SETTINGS_MEDIASTORAGE_USERLOGFOLDER).toString();
if(store && folder.size())
{
User user;
if(TT_GetUser(ttInst, m_userid, &user))
{
if(!m_logFile.isOpen())
openLogFile(m_logFile, folder, _Q(user.szNickname));
}
writeLogEntry(m_logFile, line);
}
}
break;
case MSGTYPE_CUSTOM :
{
QStringList cmd_msg = getCustomCommand(msg);
if(cmd_msg.size() >= 2 && cmd_msg[0] == TT_INTCMD_TYPING_TEXT)
{
if(cmd_msg[1] == "1")
{
ui.newmsgLabel->setText(tr("New message - remote user typing."));
if(m_remote_typing_id)
killTimer(m_remote_typing_id);
m_remote_typing_id = startTimer(REMOTE_TYPING_DELAY);
}
else
{
if(m_remote_typing_id)
killTimer(m_remote_typing_id);
m_remote_typing_id = 0;
ui.newmsgLabel->setText(tr("New message"));
}
}
break;
}
default :
break;
}
}
void servertest(char *port) {
char *request, *hostname, *response, *client_ip_address;
struct sockaddr_in clientaddr;
struct hostent *hp;
int clientlen, connfd;
// start listening and enter infinite listening loop
int listenfd = Open_listenfd(port);
while (1) {
// accept a connection
clientlen = sizeof(clientaddr);
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
// get some information from the client
hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
sizeof(clientaddr.sin_addr.s_addr), AF_INET);
client_ip_address = inet_ntoa(clientaddr.sin_addr);
// read the request from the end-user
request = read_until(connfd, "\r\n\r\n\0");
// Store the hostname from the request
hostname = parseRequest(request);
// printf("S-Parse result:%s", hostname);
if (hostname) {
// Pass on the client's request
response = clienttest(hostname, request);
// printf("S-Response result:\n%s\n", response);
//check that the response isn't empty (end-server responded)
// respond to the end-user
Rio_writen(connfd, response, strlen(response));
// writeLogEntry (only if there was a response)
if (strcmp(response, "") != 0) {
writeLogEntry(client_ip_address, hostname, strlen(response));
// printf("S-Wrote log.\n");
}
}
// Finished, close connection
Close(connfd);
// Free the buffers except
// client_ip_address is statically managed by inet_ntoa
free(request);
free(hostname);
free(response);
}
}
void RTC_SetDateTime(struct tm* ts)
{
uint8_t b[7]={0};
mktime(ts); // adjust all entries in this structure (so that all fields are in range)
// refer to K.N.King p. 694
// it calculates tm_wday and tm_yday
// convert broken date to BCD register values:
b[REG_Seconds] = (ts->tm_sec)/10 << 4 | (ts->tm_sec)%10;
b[REG_Minutes] = (ts->tm_min)/10 << 4 | (ts->tm_min)%10;
b[REG_Hours] = (ts->tm_hour)/10 << 4 | (ts->tm_hour)%10; // using 24h-format
b[REG_Day] = ts->tm_wday + 1; // tm_wday is 0...6 for sunday..saturday
b[REG_Date] = (ts->tm_mday)/10 << 4 | (ts->tm_mday)%10;
b[REG_Month] = (ts->tm_mon+1)/10 << 4 | (ts->tm_mon+1)%10;
b[REG_Year] = (ts->tm_year-100)/10 << 4 | (ts->tm_year-100)%10;
b[REG_Seconds] |= 1<<7; // start oscillator
b[REG_Day] |= 1<<3; // enable battery backup
twi_package_t twi_package=
{
.chip=RTC_SLAVE_ADDRESS,
.addr={0, 0, 0},
.addr_length=1,
.buffer=b,
.length=7
};
if(twi_master_write(&AVR32_TWI, &twi_package)==TWI_SUCCESS)
{
writeLogEntry("new time written to real-time clock\n");
}
else
{
printf("ERROR, could not write new time to real-time clock\n");
}
}
//-------------------------------------------------------------------------------------------------------
bool GlesRenderer::initializeHelpers()
{
static const char* resultVertexShader =
"attribute vec4 vertexPosition;"
"uniform vec4 textureCoordinatesAdjustment;"
"varying vec2 textureCoordinates;"
"void main()"
"{"
" gl_Position = vec4(vertexPosition.x, vertexPosition.y, 0.0, 1.0);"
" textureCoordinates = vertexPosition.zw * textureCoordinatesAdjustment.xy;"
"}\n";
static const char* resultFragmentShader =
"precision mediump float;\n"
"varying vec2 textureCoordinates;\n"
"uniform sampler2D resultTexture;\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D(resultTexture, textureCoordinates);\n"
"}\n";
GlesGlslProgram::VertexAttribute vertexAttributes[] =
{
GlesGlslProgram::VertexAttribute("vertexPosition", 0)
};
const uint8_t numVertexAttributes = sizeof(vertexAttributes) / sizeof(vertexAttributes[0]);
if(!resultRenderingProgram_.initialize(resultVertexShader, resultFragmentShader,
vertexAttributes, numVertexAttributes))
{
writeLogEntry("error: could not initialize result GLSL program");
return false;
}
textureCoordinatesAdjustmentLocation_ =
resultRenderingProgram_.getUniformLocation("textureCoordinatesAdjustment");
resultTextureLocation_ = resultRenderingProgram_.getUniformLocation("resultTexture");
if(!renderTargetContainer_.initialize(frameParameters_, parameters_))
{
writeLogEntry("error: could not initialize render target container");
return false;
}
if(!actorsRenderer_.initialize(renderTargetContainer_, frameParameters_, textureHandler_))
{
writeLogEntry("error: could not initialize actors renderer");
return false;
}
if(!lightingRenderer_.initialize(renderTargetContainer_, frameParameters_,
actorsRenderer_, textureHandler_))
{
writeLogEntry("error: could not initialize lighting renderer");
return false;
}
if(!fullScreenQuad_.initialize())
{
writeLogEntry("error: could not initialize full-screen quad");
return false;
}
if(!textureHandler_.initialize())
{
writeLogEntry("error: could not initialize texture handler");
return false;
}
if(!bloomRenderer_.initialize(renderTargetContainer_, frameParameters_,
fullScreenQuad_, textureHandler_))
{
writeLogEntry("error: could not initialize bloom renderer");
return false;
}
if(!guiRenderer_.initialize(textureHandler_, parameters_.getFileManager()))
{
writeLogEntry("error: could not initialize GUI renderer");
return false;
}
return true;
}
