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; }