static int
global_saxdb_read(struct dict *db)
{
struct record_data *hir;
time_t posted;
long flags;
unsigned long duration;
char *str, *from, *message;
dict_iterator_t it;
for(it=dict_first(db); it; it=iter_next(it))
{
hir = iter_data(it);
if(hir->type != RECDB_OBJECT)
{
log_module(G_LOG, LOG_WARNING, "Unexpected rectype %d for %s.", hir->type, iter_key(it));
continue;
}
str = database_get_data(hir->d.object, KEY_FLAGS, RECDB_QSTRING);
flags = str ? strtoul(str, NULL, 0) : 0;
str = database_get_data(hir->d.object, KEY_POSTED, RECDB_QSTRING);
posted = str ? strtoul(str, NULL, 0) : 0;
str = database_get_data(hir->d.object, KEY_DURATION, RECDB_QSTRING);
duration = str ? strtoul(str, NULL, 0) : 0;
from = database_get_data(hir->d.object, KEY_FROM, RECDB_QSTRING);
message = database_get_data(hir->d.object, KEY_MESSAGE, RECDB_QSTRING);
message_add(flags, posted, duration, from, message);
}
return 0;
}
static void
hash_cleanup(UNUSED_ARG(void *extra))
{
dict_iterator_t it, next;
DelServer(self, 0, NULL);
for (it = dict_first(channels); it; it = next) {
next = iter_next(it);
DelChannel(iter_data(it));
}
dict_delete(channels);
dict_delete(clients);
dict_delete(servers);
userList_clean(&curr_opers);
count_opers = 0;
free(slf_list);
free(slf_list_extra);
free(nuf_list);
free(nuf_list_extra);
free(ncf2_list);
free(ncf2_list_extra);
free(duf_list);
free(duf_list_extra);
free(ncf_list);
free(ncf_list_extra);
free(jf_list);
free(jf_list_extra);
free(dcf_list);
free(dcf_list_extra);
free(pf_list);
free(pf_list_extra);
free(kf_list);
free(kf_list_extra);
free(tf_list);
free(tf_list_extra);
}
QString PSV_ChartItem::getCurrentHtmMes(const double x)
{
QString str;
double dataX = getAxisPointDataX(x);
PSV::DATATYPE tempType = dataType();
if(tempType == PSV::E_DATATYPE_TIME
|| tempType == PSV::E_DATATYPE_DATE
|| tempType == PSV::E_DATATYPE_DOUBLE
|| tempType == PSV::E_DATATYPE_DATETIME)
{
QMapIterator<QString, PSV_CurveInfo > iter(m_curveDataMap);
while(iter.hasNext())
{
iter.next();
PSV_CurveInfo curveInfo = iter.value();
if(curveInfo.m_isHidden)
{
continue;
}
//暂时不支持曲线 QMap<double, double> tempValue = curveInfo.m_curveDetailDataMap;
QMap<double, double> tempValue = curveInfo.m_curveDataMap;
QString curveName = curveInfo.m_curveName;
// if(m_hideCurveNameList.contains(curveName))
// {
// continue;
// }
QString corStr = curveInfo.m_lineColor.name();
double dataY = 0.0;
QMapIterator<double, double> iter_data(tempValue);
int count = 0;
bool isFound = false;
double preX = 0.0;
double nextX = 0.0;
double preY = 0.0;
double nextY = 0.0;
while(iter_data.hasNext())
{
iter_data.next();
if(qAbs(dataX - iter_data.key()) < PSV_ZEOR)
{
dataY = iter_data.value();
isFound = true;
count = 0;
break;
}
else if(dataX > iter_data.key())
{
preX = iter_data.key();
preY = iter_data.value();
count++;
}
else
{
nextX = iter_data.key();
nextY = iter_data.value();
if(count > 0)
{
isFound = true;
}
break;
}
}
if(isFound)
{
if(count != 0)
{
if(curveInfo.m_curveType == PSV::E_CURVE_PARELLEL)
{
dataY = preY;
}
else
{
dataY = (nextY - preY) * (dataX - preX) / (nextX - preX) + preY;
}
}
str.append(QString("<b><font size= 8 color = %1>%2:%3</font><br/></b>")
.arg(corStr)
.arg(curveName)
.arg(QString::number(dataY,'f',decimal())));
}
else
{
// PSV_Public::printMes(QString("NOT fount = %1").arg(iter.key()));
}
//
}
}
if(!str.isEmpty())
{
QString xStr = getTipDataTextX(dataX);
return QString("<b><font size= 8 color = Black>%1</font></b><br/>%2").arg(xStr).arg(str);
}
return str;
}
void
global_message_args(long targets, const char *language_entry, ...)
{
struct globalMessage *message = NULL;
va_list arg_list;
dict_iterator_t it;
char response[MAXLEN];
const char *fmt;
if(!targets || !global)
return;
fmt = strdup(language_entry);
/* Notice users/opers/helpers */
for (it = dict_first(clients); it; it = iter_next(it)) {
struct userNode *luser = iter_data(it);
language_entry = user_find_message(luser, fmt);
va_start(arg_list, language_entry);
vsnprintf(response, MAXLEN-2, language_entry, arg_list);
response[MAXLEN-1] = 0;
if (message)
message_del(message);
message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", response);
if (!message)
continue;
/* opers */
if(message->flags & MESSAGE_RECIPIENT_OPERS && IsOper(luser)) {
if(luser->uplink != self)
notice_target(luser->nick, message);
if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_HELPERS) ||
(message->flags & MESSAGE_RECIPIENT_AUTHED))
continue;
}
/* helpers */
if (message->flags & MESSAGE_RECIPIENT_HELPERS && IsHelper(luser)) {
notice_target(luser->nick, message);
if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_AUTHED))
continue;
}
/* authed */
if ((message->flags & MESSAGE_RECIPIENT_AUTHED) && luser->handle_info) {
notice_target(luser->nick, message);
if (message->flags & MESSAGE_RECIPIENT_LUSERS)
continue;
}
/* users */
if (message->flags & MESSAGE_RECIPIENT_LUSERS) {
notice_target(luser->nick, message);
}
}
message_del(message);
}
static void
message_send(struct globalMessage *message)
{
struct userNode *user;
unsigned long n;
dict_iterator_t it;
if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
{
dict_iterator_t it;
for (it = dict_first(channels); it; it = iter_next(it)) {
struct chanNode *chan = iter_data(it);
notice_target(chan->name, message);
}
}
if(message->flags & MESSAGE_RECIPIENT_RCHANNELS)
{
dict_iterator_t it;
for (it = dict_first(channels); it; it = iter_next(it)) {
struct chanNode *chan = iter_data(it);
if (chan->channel_info)
notice_target(chan->name, message);
}
}
if(message->flags & MESSAGE_RECIPIENT_LUSERS)
{
notice_target("$*", message);
return;
}
if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
{
char announce;
for (it = dict_first(clients); it; it = iter_next(it)) {
user = iter_data(it);
if (user->uplink == self) continue;
announce = user->handle_info ? user->handle_info->announcements : '?';
if (announce == 'n') continue;
if ((announce == '?') && !global_conf.announcements_default) continue;
notice_target(user->nick, message);
}
}
if(message->flags & MESSAGE_RECIPIENT_OPERS)
{
for(n = 0; n < curr_opers.used; n++)
{
user = curr_opers.list[n];
if(user->uplink != self)
{
notice_target(user->nick, message);
}
}
}
if(message->flags & MESSAGE_RECIPIENT_HELPERS)
{
for(n = 0; n < curr_helpers.used; n++)
{
user = curr_helpers.list[n];
if (IsOper(user))
continue;
notice_target(user->nick, message);
}
}
if(message->flags & MESSAGE_RECIPIENT_AUTHED)
{
dict_iterator_t it;
for (it = dict_first(clients); it; it = iter_next(it)) {
struct userNode *luser = iter_data(it);
if (luser->handle_info)
notice_target(luser->nick, message);
}
}
}
