QGraphicsItem* CGraphicsPolylineItem::createItem()
{
QGraphicsPathItem* pItem = new QGraphicsPathItem(m_Parent);
drawPen(pItem);
QPainterPath path;
QPolygonF d;
QStringList lstPath = GET_VALUE(d).split(' ');
int iCount = lstPath.size();
for (int j = 0; j < iCount; j++)
{
QStringList lstPoint = lstPath[j].split(',');
d.append(QPointF(lstPoint[0].toDouble(), lstPoint[1].toDouble()));
lstPoint.clear();
}
if (d.count() > 0)
{
path.moveTo(d[0]);
}
for (int i = 1; i < d.count() ; i++)
{
path.lineTo(d[i]);
}
pItem->setPath(path);
return pItem;
}
static int doInitialize (struct nc_state_t *nc)
{
char *s = NULL;
// set up paths of Eucalyptus commands NC relies on
snprintf (nc->get_info_cmd_path, MAX_PATH, EUCALYPTUS_GET_KVM_INFO, nc->home, nc->home);
strcpy(nc->uri, HYPERVISOR_URI);
nc->convert_to_disk = 1;
nc->capability = HYPERVISOR_HARDWARE; // TODO: indicate virtio support?
s = system_output (nc->get_info_cmd_path);
#define GET_VALUE(name,var) \
if (get_value (s, name, &var)) { \
logprintfl (EUCAFATAL, "error: did not find %s in output from %s\n", name, nc->get_info_cmd_path); \
if (s) free (s); \
return ERROR_FATAL; \
}
GET_VALUE("nr_cores", nc->cores_max);
GET_VALUE("total_memory", nc->mem_max);
if (s) free(s);
// we leave 256M to the host
nc->mem_max -= 256;
return OK;
}
//!
//! Initialize the NC state structure for the KVM hypervisor.
//!
//! @param[in] nc a pointer to the NC state structure to initialize
//!
//! @return Always return EUCA_OK
//!
static int doInitialize(struct nc_state_t *nc)
{
#define GET_VALUE(_name, _var) \
{ \
if (get_value (s, (_name), &(_var))) { \
logprintfl (EUCAFATAL, "did not find %s in output from %s\n", (_name), nc->get_info_cmd_path); \
EUCA_FREE(s); \
return (EUCA_FATAL_ERROR); \
} \
}
char *s = NULL;
// set up paths of Eucalyptus commands NC relies on
snprintf(nc->get_info_cmd_path, MAX_PATH, EUCALYPTUS_GET_KVM_INFO, nc->home, nc->home);
strcpy(nc->uri, HYPERVISOR_URI);
nc->convert_to_disk = 1;
nc->capability = HYPERVISOR_HARDWARE; //! @todo indicate virtio support?
s = system_output(nc->get_info_cmd_path);
GET_VALUE("nr_cores", nc->cores_max);
GET_VALUE("total_memory", nc->mem_max);
EUCA_FREE(s);
// we leave 256M to the host
nc->mem_max -= 256;
return (EUCA_OK);
}
void RarVM::Execute(VM_PreparedProgram *Prg)
{
memcpy(R,Prg->InitR,sizeof(Prg->InitR));
unsigned int GlobalSize=Min(Prg->GlobalData.Size(),VM_GLOBALMEMSIZE);
if (GlobalSize)
memcpy(Mem+VM_GLOBALMEMADDR,&Prg->GlobalData[0],GlobalSize);
unsigned int StaticSize=Min(Prg->StaticData.Size(),VM_GLOBALMEMSIZE-GlobalSize);
if (StaticSize)
memcpy(Mem+VM_GLOBALMEMADDR+GlobalSize,&Prg->StaticData[0],StaticSize);
R[7]=VM_MEMSIZE;
Flags=0;
VM_PreparedCommand *PreparedCode=Prg->AltCmd ? Prg->AltCmd:&Prg->Cmd[0];
if (!ExecuteCode(PreparedCode,Prg->CmdCount))
PreparedCode[0].OpCode=VM_RET;
unsigned int NewBlockPos=GET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x20])&VM_MEMMASK;
unsigned int NewBlockSize=GET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x1c])&VM_MEMMASK;
if (NewBlockPos+NewBlockSize>=VM_MEMSIZE)
NewBlockPos=NewBlockSize=0;
Prg->FilteredData=Mem+NewBlockPos;
Prg->FilteredDataSize=NewBlockSize;
Prg->GlobalData.Reset();
unsigned int DataSize=Min(GET_VALUE(false,(unsigned int*)&Mem[VM_GLOBALMEMADDR+0x30]),VM_GLOBALMEMSIZE);
if (DataSize!=0)
{
Prg->GlobalData.Add(DataSize+VM_FIXEDGLOBALSIZE);
memcpy(&Prg->GlobalData[0],&Mem[VM_GLOBALMEMADDR],DataSize+VM_FIXEDGLOBALSIZE);
}
}
static int w_ds_select(struct sip_msg* msg, char* set, char* alg, int mode)
{
unsigned int algo_flags, set_flags;
str s_algo = {NULL, 0};
str s_set = {NULL, 0};
int a, s;
if(msg==NULL)
return -1;
GET_VALUE("destination set", set, s, s_set, set_flags);
if (!(set_flags&PARAM_INT)) {
if (set_flags&PARAM_STR)
LM_ERR("unable to get destination set from [%.*s]\n", s_set.len, s_set.s);
else
LM_ERR("unable to get destination set\n");
return -1;
}
GET_VALUE("algorithm", alg, a, s_algo, algo_flags);
if (!(algo_flags&PARAM_INT)) {
if (algo_flags&PARAM_STR)
LM_ERR("unable to get algorithm from [%.*s]\n", s_algo.len, s_algo.s);
else
LM_ERR("unable to get algorithm\n");
return -1;
}
return ds_select_dst(msg, s, a, mode);
}
QGraphicsItem* CGraphicsDiamondItem::createItem()
{
QGraphicsPolygonItem* pItem = new QGraphicsPolygonItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
qreal x;
qreal y;
qreal w;
qreal h;
x = GET_VALUE(x).toFloat();
y = GET_VALUE(y).toFloat();
w = GET_VALUE(w).toFloat();
h = GET_VALUE(h).toFloat();
QPolygonF d;
d.append(QPointF(x + w/2,y));
d.append(QPointF(x + w,y + h/2));
d.append(QPointF(x + w/2,y + h));
d.append(QPointF(x,y + h/2));
pItem->setPolygon(d);
return pItem;
}
void CGraphicsItemBase::drawBrush(QAbstractGraphicsShapeItem* pItem)
{
QBrush brush;
QStringList lstFc = GET_VALUE(fc).split(',');
QColor fc = QColor::fromRgb(lstFc[0].toInt(),lstFc[1].toInt(),lstFc[2].toInt());
brush.setColor(fc);
brush.setStyle(Qt::BrushStyle(GET_VALUE(fm).toInt()));
pItem->setBrush(brush);
}
QGraphicsItem* CGraphicsEllipseItem::createItem()
{
QGraphicsEllipseItem* pItem = new QGraphicsEllipseItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
pItem->setRect(GET_VALUE(cx).toInt(), GET_VALUE(cy).toInt(), GET_VALUE(rx).toInt(), GET_VALUE(ry).toInt());
return pItem;
}
QPen CGraphicsItemBase::drawPen()
{
QPen pen;
QStringList lstLc = GET_VALUE(lc).split(',');
QColor lc = QColor::fromRgb(lstLc[0].toInt(),lstLc[1].toInt(),lstLc[2].toInt());
pen.setColor(lc);
pen.setWidth(GET_VALUE(lw).toInt());
pen.setStyle(Qt::PenStyle(GET_VALUE(ls).toInt()));
return pen;
}
QGraphicsItem* CGraphicsRectItem::createItem()
{
QGraphicsRectItem* pItem = new QGraphicsRectItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
pItem->setRect(GET_VALUE(x).toInt(),GET_VALUE(y).toInt(),GET_VALUE(w).toInt(),GET_VALUE(h).toInt());
return pItem;
}
bool op_or(t_vm *vm, t_process *process, uint32_t const *args,
uint8_t args_types)
{
uint32_t val;
val = GET_VALUE(vm, process, args, args_types, 0)
| GET_VALUE(vm, process, args, args_types, 1);
SET_CARRY(process, val);
if (args[2] >= 1 && args[2] <= REG_NUMBER)
process->reg[args[2] - 1] = val;
return (true);
}
QGraphicsItem* CGraphicsPixmapItem::createItem()
{
QGraphicsPixmapItem* pItem = new QGraphicsPixmapItem(m_Parent);
qreal x = GET_VALUE(x).toFloat();
qreal y = GET_VALUE(y).toFloat();
qreal w = GET_VALUE(w).toFloat();
qreal h = GET_VALUE(h).toFloat();
QPixmap pix(w,h);
QString strFile = m_imageDir + GET_VALUE(ahref);
pix.load(strFile);
pItem->setOffset(x,y);
pItem->setPixmap(pix);
return pItem;
}
QGraphicsItem* CGraphicsTriangleItem::createItem()
{
QGraphicsPolygonItem* pItem = new QGraphicsPolygonItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
QPolygonF d;
d.append(QPointF(-GET_VALUE(w).toDouble()/2,GET_VALUE(h).toDouble()/2));
d.append(QPointF(GET_VALUE(w).toDouble()/2,GET_VALUE(h).toDouble()/2));
d.append(QPointF(0,-GET_VALUE(h).toDouble()/2));
pItem->setPolygon(d);
return pItem;
}
setval_t set_remove(set_t *s, setkey_t k)
{
ptst_t *ptst;
node_t *y, *z;
qnode_t z_qn;
setval_t ov = NULL;
k = CALLER_TO_INTERNAL_KEY(k);
ptst = critical_enter();
z = &s->root;
while ( (y = (k <= z->k) ? z->l : z->r) != NULL )
z = y;
if ( z->k == k )
{
mcs_lock(&z->lock, &z_qn);
if ( !IS_GARBAGE(z) )
{
ov = GET_VALUE(z->v);
SET_VALUE(z->v, NULL);
}
mcs_unlock(&z->lock, &z_qn);
}
if ( ov != NULL )
delete_finish(ptst, z);
critical_exit(ptst);
return ov;
}
void CPerigeeCopyOptions::Load()
{
HKEY key = NULL;
DWORD disposition = 0;
RegCreateKeyEx(HKEY_CURRENT_USER, app_key, 0, NULL, 0, KEY_READ, NULL, &key, &disposition);
GET_VALUE(key, (overwrite_spec), overwrite, overwrite_prompt);
GET_VALUE(key, !!, skip_error_files, false);
GET_VALUE(key, !!, overwrite_read_only, true);
GET_VALUE(key, !!, clear_read_only_after_copy, false);
GET_VALUE(key, !!, only_copy_archive, false);
GET_VALUE(key, !!, clear_archive_after_copy, false);
GET_VALUE(key, !!, prompt_for_confirmation_when_deleting, true);
GET_VALUE(key, !!, use_perigee_copy_by_default_when_dragging, false);
GET_VALUE(key, !!, skip_inventory, false);
GET_VALUE(key, !!, debug_prompt, false);
GET_VALUE(key, !!, recycle, true);
GET_VALUE(key, !!, wait_for_previous, false);
GET_VALUE(key, !!, wait_for_debugger, false);
RegCloseKey(key);
}
bool Config::get(const char* section, const char* key, float& ret, float deflt) {
GET_VALUE(section, key, ret, deflt);
char* locale = nls_locale_to_c();
ret = atof(value);
nls_locale_from_c(locale);
return true;
}
static int w_ds_select_addr(
sip_msg_t *msg, char *set, char *alg, char *limit, int mode)
{
unsigned int algo_flags, set_flags, limit_flags;
str s_algo = STR_NULL;
str s_set = STR_NULL;
str s_limit = STR_NULL;
int a, s, l;
if(msg == NULL)
return -1;
GET_VALUE("destination set", set, s, s_set, set_flags);
if(!(set_flags & PARAM_INT)) {
if(set_flags & PARAM_STR)
LM_ERR("unable to get destination set from [%.*s]\n", s_set.len,
s_set.s);
else
LM_ERR("unable to get destination set\n");
return -1;
}
GET_VALUE("algorithm", alg, a, s_algo, algo_flags);
if(!(algo_flags & PARAM_INT)) {
if(algo_flags & PARAM_STR)
LM_ERR("unable to get algorithm from [%.*s]\n", s_algo.len,
s_algo.s);
else
LM_ERR("unable to get algorithm\n");
return -1;
}
if(limit) {
GET_VALUE("limit", limit, l, s_limit, limit_flags);
if(!(limit_flags & PARAM_INT)) {
if(limit_flags & PARAM_STR)
LM_ERR("unable to get dst number limit from [%.*s]\n",
s_limit.len, s_limit.s);
else
LM_ERR("unable to get dst number limit\n");
return -1;
}
} else {
l = -1; /* will be casted to a rather big unsigned value */
}
return ds_select_dst_limit(msg, s, a, (unsigned int)l, mode);
}
QGraphicsItem* CGraphicsLineItem::createItem()
{
QGraphicsLineItem* pItem = new QGraphicsLineItem(m_Parent);
drawPen(pItem);
QPointF start;
start.setX(GET_VALUE(x1).toFloat());
start.setY(GET_VALUE(y1).toFloat());
QPointF end;
end.setX(GET_VALUE(x2).toFloat());
end.setY(GET_VALUE(y2).toFloat());
QLineF line(start,end);
pItem->setLine(line);
return pItem;
}
QGraphicsItem* CGraphicsCircleArcItem::createItem()
{
QGraphicsPathItem* pItem = new QGraphicsPathItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
QPainterPath path;
qreal cx = GET_VALUE(cx).toFloat();
qreal cy = GET_VALUE(cy).toFloat();
qreal r = GET_VALUE(r).toFloat();
qreal a1 = GET_VALUE(a1).toFloat();
qreal a2 = GET_VALUE(a2).toFloat();
QRectF round(cx-r,cy-r,2*r,2*r);
qreal span = a2 - a1;
path.arcTo(round,a1*16,span*16);
pItem->setPath(path);
return pItem;
}
QGraphicsItem* CGraphicsTextItem::createItem()
{
QGraphicsSimpleTextItem* pItem = new QGraphicsSimpleTextItem(m_Parent);
QFont font;
//字体宽度
font.setWeight(GET_VALUE(p_FontWidth).toInt());
//字体大小
font.setPixelSize(GET_VALUE(fs).toInt());
//字间距
font.setWordSpacing(GET_VALUE(p_FontInterval).toInt());
//字体高度
//字体类型
QString strFamily(GET_VALUE(ff));
if (!strFamily.isEmpty())
{
font.setFamily(strFamily);
}
pItem->setFont(font);
//字体颜色
QPen pen;
QStringList lstLc = GET_VALUE(lc).split(',');
pen.setColor(QColor::fromRgb(lstLc[0].toInt(),lstLc[1].toInt(),lstLc[2].toInt()));
pItem->setPen(pen);
pItem->setText(GET_VALUE(ts));
return pItem;
}
int printpkt_print(struct ulogd_key *res, char *buf)
{
char *buf_cur = buf;
if (pp_is_valid(res, 1))
buf_cur += sprintf(buf_cur, "%s", (char *) GET_VALUE(res, 1).ptr);
if (pp_is_valid(res, 2) && pp_is_valid(res, 3)) {
buf_cur += sprintf(buf_cur," IN=%s OUT=%s ",
(char *) GET_VALUE(res, 2).ptr,
(char *) GET_VALUE(res, 3).ptr);
}
/* FIXME: configurable */
if (pp_is_valid(res, 4))
buf_cur += sprintf(buf_cur, "MAC=%s ",
(char *) GET_VALUE(res, 4).ptr);
else
buf_cur += sprintf(buf_cur, "MAC= ");
if (pp_is_valid(res, 5))
buf_cur += sprintf(buf_cur, "SRC=%s ", inet_ntoa(
(struct in_addr) {htonl(GET_VALUE(res, 5).ui32)}));
setval_t set_lookup(set_t *s, setkey_t k)
{
node_t *n;
setval_t v = NULL;
ptst_t *ptst;
k = CALLER_TO_INTERNAL_KEY(k);
ptst = critical_enter();
n = weak_find(&s->root, k);
if ( n != NULL ) v = GET_VALUE(n);
critical_exit(ptst);
return v;
}
bool IsoDepTag::startIsoDepTag() {
uint8_t rats = listenRATS();
if (rats == 0xFF) {
LOGE("RATS(Request for Answer to select) is not received");
return false;
}
if (ovrImpl != NULL) {
ovrImpl->onInitiatorDetected(*this);
} else {
defaultImpl->onInitiatorDetected(*this);
}
uint16_t rxresult = 0;
while (!IS_ERROR((rxresult = ulhw->tgGetData(rxBuf)))) {
IsoApdu::parse(rxBuf, GET_VALUE(rxresult), this);
}
return true;
}
G_MODULE_EXPORT
void chart_btn_clicked_cb ()
{
gint32 *buf;
guint32 size;
if (!serial_port_get_feedback (&buf, &size)) {
print_status ("Serial port timeout");
return;
}
chart_apply_data (GET_VALUE (GET_OBJECT ("setpoint_adj")), buf, size);
print_status ("OK");
gtk_widget_queue_draw (chart_da);
g_free (buf);
}
bool Config::get(const char* section, const char* key, bool& ret, bool deflt) {
GET_VALUE(section, key, ret, deflt);
str_tolower((unsigned char*)value);
int len = strlen(value);
if (len == 4 && (strncmp(value, "true", 4) == 0))
ret = true;
else if (len == 5 && (strncmp(value, "false", 5) == 0))
ret = false;
else if (len == 1 && (strncmp(value, "1", 1) == 0))
ret = true;
else if (len == 1 && (strncmp(value, "0", 1) == 0))
ret = false;
else
ret = deflt;
return true;
}
G_MODULE_EXPORT
void gains_set_btn_clicked_cb (GtkButton *button, gpointer unused)
{
gint32 VL = round (GET_VALUE (GET_OBJECT ("speed_adj")));
gint32 kf = round (GET_VALUE (GET_OBJECT ("kF_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kp = round (GET_VALUE (GET_OBJECT ("kP_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 ki = round (GET_VALUE (GET_OBJECT ("kI_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kd = round (GET_VALUE (GET_OBJECT ("kD_adj")) * (double) (1 << FIXED_POINT_POS));
gint32 kg = round (GET_VALUE (GET_OBJECT ("kG_adj")) * (double) (1 << FIXED_POINT_POS));
serial_port_send_parameters (VL, kf, kp, ki, kd, kg);
print_status ("OK");
}
QGraphicsItem* CGraphicsPolygonItem::createItem()
{
QGraphicsPolygonItem* pItem = new QGraphicsPolygonItem(m_Parent);
drawPen(pItem);
drawBrush(pItem);
QPolygonF d;
QStringList lstPath = GET_VALUE(d).split(' ');
int iCount = lstPath.size();
for (int j = 0; j < iCount; j++)
{
QStringList lstPoint = lstPath[j].split(',');
d.append(QPointF(lstPoint[0].toDouble(), lstPoint[1].toDouble()));
lstPoint.clear();
}
pItem->setPolygon(d);
return pItem;
}
void util_spawn(void)
{
char buf[256];
$DESCRIPTOR(d_buf,buf);
$DESCRIPTOR(d_ent," ");
d_ent.dsc$a_pointer = "COMMAND";
d_ent.dsc$w_length = 7;
if (CLI$PRESENT(&d_ent) == CLI$_PRESENT)
{
if (CLI$GET_VALUE(&d_ent,&d_buf) == SS$_NORMAL)
lib$spawn(&d_buf);
return;
}
d_buf.dsc$w_length = 0;
lib$spawn(&d_buf);
return;
}
setval_t set_lookup(set_t *s, setkey_t k)
{
ptst_t *ptst;
node_t *m, *n;
setval_t v;
k = CALLER_TO_INTERNAL_KEY(k);
ptst = critical_enter();
n = &s->root;
while ( (m = (k <= n->k) ? n->l : n->r) != NULL )
n = m;
v = (k == n->k) ? GET_VALUE(n->v) : NULL;
if ( v == GARBAGE_VALUE ) v = NULL;
critical_exit(ptst);
return v;
}
int db_list_iter(brain_t brain, enum list type, int (*callback)(void *data, word_t ref, const char *word), void *data) {
PGresult *res;
unsigned int num, i;
const char *param[2];
char tmp[2][32];
if (brain == 0) return -EINVAL;
if (db_connect())
return -EDB;
SET_PARAM(param, tmp, 0, brain);
SET_PARAM(param, tmp, 1, type);
res = PQexecPrepared(conn, "list_iter", 2, param, NULL, NULL, 0);
if (PQresultStatus(res) != PGRES_TUPLES_OK) goto fail;
num = PQntuples(res);
for (i = 0; i < num; i++) {
word_t ref;
char *word;
int ret;
GET_VALUE(res, i, 0, ref);
word = PQgetvalue(res, i, 1);
if (word == NULL) goto fail;
ret = callback(data, ref, word);
if (ret) goto fail;
}
PQclear(res);
return OK;
fail:
log_error("db_list_iter", PQresultStatus(res), PQresultErrorMessage(res));
PQclear(res);
return -EDB;
}
