void CDelayOrderIDCvt_HK::DoAddNewDelayReq(Trade_Env eEnv, INT64 nLocalID)
{
LP_DelayCvtInfo pInfo = DoFindReqObj(eEnv, nLocalID);
if (pInfo)
return;
pInfo = new DelayCvtInfo(eEnv, nLocalID);
CHECK_RET(pInfo, NORET);
m_vtReq.push_back(pInfo);
}
static
GF_Err gdip_set_vertex_path(GF_STENCIL _this, GF_Path *path)
{
GPSTEN();
GpPath *p;
CHECK_RET(GF_STENCIL_VERTEX_GRADIENT);
p = gdip_create_path(path);
if (_sten->pRadial) GdipDeleteBrush(_sten->pRadial);
GdipCreatePathGradientFromPath(p, &_sten->pRadial);
GdipDeletePath(p);
return GF_OK;
}
INT64 CDelayOrderIDCvt_HK::FindSvrOrderID( Trade_Env eEnv, INT64 nLocalID, bool bDelayFindAndNotify)
{
CHECK_RET(nLocalID != 0, 0);
INT64 nOrderID = DoFindSvrOrderID(eEnv, nLocalID);
if (0 == nOrderID && bDelayFindAndNotify)
{
DoAddNewDelayReq(eEnv, nLocalID);
StartTime_LoopFind();
}
return nOrderID;
}
static
GF_Err gdip_set_vertex_colors (GF_STENCIL _this, u32 *colors, u32 nbCol)
{
int col = nbCol;
GPSTEN();
CHECK_RET(GF_STENCIL_VERTEX_GRADIENT);
GpStatus ret;
if (!_sten->pRadial) return GF_BAD_PARAM;
ret = GdipSetPathGradientSurroundColorsWithCount(_sten->pRadial, (ARGB *) colors, &col);
return GF_OK;
}
static
GF_Err gdip_set_brush_color(GF_STENCIL _this, GF_Color c)
{
GPSTEN();
CHECK_RET(GF_STENCIL_SOLID);
if (!_sten->pSolid)
GdipCreateSolidFill(c, &_sten->pSolid);
else
GdipSetSolidFillColor(_sten->pSolid, c);
return GF_OK;
}
static int _mem_init()
{
//printf("Init hisi mpp sys & vb\n");
MPP_SYS_CONF_S stSysConf = {0};
stSysConf.u32AlignWidth = MPP_SYS_ALIGN_WIDTH;
VB_CONF_S stVbConf;
memset(&stVbConf,0,sizeof(VB_CONF_S));
unsigned int u32BlkSize;
stVbConf.u32MaxPoolCnt = 128;
SIZE_S size;
size.u32Height = 1088;
size.u32Width = 1920;
u32BlkSize = calc_pic_vb_blk_size(&size, PIXEL_FORMAT_YUV_SEMIPLANAR_420, MPP_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 15;
CHECK_RET(HI_MPI_VB_Exit(),"HI_MPI_VB_Exit");
CHECK_RET(HI_MPI_SYS_Exit(),"HI_MPI_SYS_Exit");
CHECK_RET(HI_MPI_VB_SetConf(&stVbConf),"HI_MPI_VB_SetConf");
CHECK_RET(HI_MPI_VB_Init(),"HI_MPI_VB_Init");
CHECK_RET(HI_MPI_SYS_SetConf(&stSysConf),"HI_MPI_SYS_SetConf");
CHECK_RET(HI_MPI_SYS_Init(),"HI_MPI_SYS_Init");
return HI_SUCCESS;
}
void
wxMFrame::SaveState(const char *name, wxWindow *frame, int flags)
{
wxConfigBase *pConf = GetFrameOptionsConfig(name);
if ( !pConf )
return;
if ( flags & Save_State )
{
wxFrame *fr = wxDynamicCast(frame, wxFrame);
CHECK_RET( fr, "should have a frame when saving state" );
if ( flags & Save_View )
{
UpdateBoolConfigValue(pConf, MP_SHOW_TOOLBAR,
fr->GetToolBar() != NULL);
UpdateBoolConfigValue(pConf, MP_SHOW_STATUSBAR,
fr->GetStatusBar() != NULL);
}
UpdateBoolConfigValue(pConf, MP_SHOW_FULLSCREEN, fr->IsFullScreen());
// IsIconized() is broken in wxGTK, it returns TRUE sometimes when the
// frame is not at all iconized - no idea why :-(
#ifdef __WXGTK__
bool isIconized = false;
#else
bool isIconized = fr->IsIconized();
#endif
bool isMaximized = fr->IsMaximized();
UpdateBoolConfigValue(pConf, MP_ICONISED, isIconized);
UpdateBoolConfigValue(pConf, MP_MAXIMISED, isMaximized);
if ( isMaximized || isIconized )
{
// don't remember the coords in this case: wxWindows returns
// something weird for them for iconized frames and we don't need
// them for maximized ones anyhow
return;
}
}
int x, y;
frame->GetPosition(&x, &y);
pConf->Write(GetOptionName(MP_XPOS), (long)x);
pConf->Write(GetOptionName(MP_YPOS), (long)y);
frame->GetSize(&x,&y);
pConf->Write(GetOptionName(MP_WIDTH), (long)x);
pConf->Write(GetOptionName(MP_HEIGHT), (long)y);
}
//tomodify 6(数组等复杂结构或单层的结构体)
bool CProtoOrderUpdatePush::MakeProtoBody_Ack(Json::Value &jsnVal, const ProtoAckDataType &data)
{
CHECK_RET(warn_if_prop_exists(jsnVal, KEY_ACK_DATA), false);
VT_PROTO_FIELD vtField;
GetProtoBodyField_Ack(vtField, data.body);
Json::Value &jsnBody = jsnVal[KEY_ACK_DATA];
bool bSuc = CProtoParseBase::MakeProtoFields(jsnBody, vtField);
CHECK_OP(bSuc, NOOP);
return bSuc;
}
void CPluginPlaceOrder::NotifyOnPlaceOrder(UINT nCookie, Trade_SvrResult enSvrRet, UINT64 nLocalID, UINT16 nErrCode)
{
CHECK_RET(nCookie, NORET);
CHECK_RET(m_pTradeOp && m_pHKTradeServer, NORET);
VT_REQ_TRADE_DATA::iterator itReq = m_vtReqData.begin();
StockDataReq *pFindReq = NULL;
for ( ; itReq != m_vtReqData.end(); ++itReq )
{
StockDataReq *pReq = *itReq;
CHECK_OP(pReq, continue);
if ( pReq->dwLocalCookie == nCookie )
{
pFindReq = pReq;
break;
}
}
CHECK_RET(pFindReq, NORET);
TradeAckType ack;
ack.head = pFindReq->req.head;
ack.head.nErrCode = nErrCode;
if ( nErrCode )
{
WCHAR szErr[256] = L"";
if ( m_pTradeOp->GetErrDesc(nErrCode, szErr) )
CA::Unicode2UTF(szErr, ack.head.strErrDesc);
}
//tomodify 4
ack.body.nCookie = pFindReq->req.body.nCookie;
ack.body.nLocalID = nLocalID;
ack.body.nSvrResult = enSvrRet;
HandleTradeAck(&ack, pFindReq->sock);
m_vtReqData.erase(itReq);
delete pFindReq;
}
//tomodify 4(数组等复杂结构或单层的结构体)
bool CProtoBasicPrice::ParseProtoBody_Ack(const Json::Value &jsnVal, ProtoAckDataType &data)
{
CHECK_RET(warn_if_prop_not_set(jsnVal, KEY_ACK_DATA), false);
VT_PROTO_FIELD vtField;
GetProtoBodyField_Ack(vtField, data.body);
const Json::Value &jsnBody = jsnVal[KEY_ACK_DATA];
bool bSuc = CProtoParseBase::ParseProtoFields(jsnBody, vtField);
CHECK_OP(bSuc, NOOP);
return bSuc;
}
void MFolderCache::Remove(MFolder *folder)
{
Check();
// don't use name here - the folder might have been renamed
int index = ms_aFolders.Index(folder);
CHECK_RET( index != wxNOT_FOUND,
_T("can't remove folder from cache because it's not in it") );
ms_aFolderNames.RemoveAt((size_t)index);
ms_aFolders.RemoveAt((size_t)index);
}
//tomodify 5(数组等复杂结构或单层的结构体)
bool CProtoGearPrice::MakeProtoBody_Req(Json::Value &jsnVal, const ProtoReqDataType &data)
{
CHECK_RET(warn_if_prop_exists(jsnVal, KEY_REQ_PARAM), false);
VT_PROTO_FIELD vtField;
GetProtoBodyField_Req(vtField, data.body);
Json::Value &jsnBody = jsnVal[KEY_REQ_PARAM];
bool bSuc = CProtoParseBase::MakeProtoFields(jsnBody, vtField);
CHECK_OP(bSuc, NOOP);
return bSuc;
}
int main(int argc, char* argv[])
{
//Process::SetProcessSignal();
#ifndef WIN32
setsid();
if (fork() > 0) exit(0); /* run in backgroud */
#endif
int iRet = 0;
TADD_OFFSTART("OFFLINE","mdbServer", 0,true);
try
{
TMdbServerCenter tServer;
if (2 == argc && TMdbNtcStrFunc::StrNoCaseCmp(argv[1], "stop") == 0)
{
CHECK_RET(tServer.Stop(), "mdbServer stop failed.");
}
else if (1 == argc || (2 == argc && TMdbNtcStrFunc::StrNoCaseCmp(argv[1], "start") == 0))
{
CHECK_RET(tServer.Init(), "mdbServer init failed.");
CHECK_RET(tServer.Start(), "mdbServer start failed.");
}
else
{
printf("Invalid command.\n");
}
}
catch(TMdbException& e)
{
printf("ERROR_SQL=%s.\nERROR_MSG=%s\n", e.GetErrSql(), e.GetErrMsg());
}
catch(...)
{
printf("Unknown error!\n");
}
return 0;
}
/******************************************************************************
* 函数名称 : Init
* 函数描述 : 初始化
* 输入 :
* 输出 :
* 返回值 : 0 - 成功!0 -失败
* 作者 : jin.shaohua
*******************************************************************************/
int TMdbTableCtrl::Init(const char * sDsn,const char * sTablename)
{
int iRet = 0;
CHECK_OBJ(sDsn);
m_pShmDsn = TMdbShmMgr::GetShmDSN(sDsn);
CHECK_OBJ(m_pShmDsn);
if(NULL != sTablename)
{
m_pTable = m_pShmDsn->GetTable(sTablename);
CHECK_OBJ(m_pTable);
CHECK_RET(m_tTSCtrl.Init(sDsn,m_pTable->m_sTablespaceName),"init failed.");
}
return iRet;
}
//设置观测点
int SetObservePoint(char* argv[])
{
int iRet = 0;
char * sDsn = argv[1];
TMdbShmDSN * pShmDsn = TMdbShmMgr::GetShmDSN(sDsn);
CHECK_OBJ(pShmDsn);
TObservePoint * pObPoint = pShmDsn->GetObPiontByName(argv[2]);
CHECK_OBJ(pObPoint);
TObserveMgr tObMgr;
TObserveBase * pBase = tObMgr.GetObserveInst(pObPoint->m_iType);
CHECK_OBJ(pBase);
CHECK_RET(pBase->Init(sDsn,pObPoint->m_iType),"int[%s,%d] error.",sDsn,pObPoint->m_iType);
TADD_NORMAL("Parse param[%s]",argv[4]);
//先检测参数
CHECK_RET(pBase->ParseParam(argv[4]),"parse Param[%s] error.",argv[4]);
SAFESTRCPY(pObPoint->m_sParam,sizeof(pObPoint->m_sParam),argv[4]);
//检测结束时间
if(TMdbNtcStrFunc::IsDigital(argv[3]))
{
long long llObSec = TMdbNtcStrFunc::StrToInt(argv[3]);
if(llObSec <= 0)
{//停止观测
pBase->StopObServe();
}
else
{//设置观测时间
gettimeofday(&(pObPoint->m_tTerminal), NULL);
pObPoint->m_tTerminal.tv_sec += llObSec;
}
}
else
{
CHECK_RET(ERR_APP_INVALID_PARAM,"End-time[%s] is error.",argv[3]);
}
ShowObservePoint(argv);
return iRet;
}
int main(int argc, char* argv[])
{
if(argc != 2 || strcmp(argv[1],"-h")==0||strcmp(argv[1],"-H")==0)
{
PrintUsage(argv[0]);
return 0;
}
/* run in backgroud */
#ifndef WIN32
setsid();
if (fork() > 0) exit(0);
#endif
char sName[64];
memset(sName, 0, sizeof(sName));
snprintf(sName,sizeof(sName), "%s %s", argv[0], argv[1]);
TADD_OFFSTART(argv[0],sName, 0, false);
int iRet = 0;
try
{
TShadowFlushCtrl tFlushCtrl;
CHECK_RET(tFlushCtrl.Init(argv[1]),"Init Flush process(shadow mode) failed.");
CHECK_RET(tFlushCtrl.Run(),"Flush process(shadow mode) failed.");
}
catch(TMDBDBExcpInterface& e)
{
printf("ERROR_SQL=%s.\nERROR_MSG=%s\n", e.GetErrSql(), e.GetErrMsg());
}
catch(...)
{
printf("Unknown error!\n");
}
return iRet;
}
bool CProtoGearPrice::MakeJson_Req(Json::Value &jsnVal)
{
CHECK_RET(m_pReqData != NULL, false);
bool bSuc = true;
do
{
bSuc &= MakeProtoHead_Req(jsnVal, m_pReqData->head);
CHECK_OP(bSuc, break);
bSuc &= MakeProtoBody_Req(jsnVal, *m_pReqData);
CHECK_OP(bSuc, break);
} while (0);
return bSuc;
}
//检查该用户的权限
int CheckConStrValid(char* dsn, char* uid, char* pwd)
{
int iRet = 0;//上载SYS配置文件
TMdbConfig *pMdbConfig = TMdbConfigMgr::GetDsnConfig(dsn);
CHECK_OBJ(pMdbConfig);
if(strlen(uid) == 0 || strlen(pwd) == 0)
{
TADD_ERROR(ERR_APP_INT_VALUE_INVALID,"the username or password can't be empty");
return ERR_APP_INT_VALUE_INVALID;
}
else
{
CHECK_RET(pMdbConfig->CheckParam(uid, pwd, dsn), "input uid or password error.");
}
//校验用户权限
if(pMdbConfig->GetAccess() != MDB_ADMIN)
{
CHECK_RET(ERR_DB_PRIVILEGE_INVALID,"No admin access=[%c].",pMdbConfig->GetAccess());
}
return iRet;
}
bool CProtoQueryHKOrder::ParseJson_Req(const Json::Value &jsnVal)
{
CHECK_RET(m_pReqData != NULL, false);
bool bSuc = true;
do
{
bSuc &= ParseProtoHead_Req(jsnVal, m_pReqData->head);
CHECK_OP(bSuc, break);
bSuc &= ParseProtoBody_Req(jsnVal, *m_pReqData);
CHECK_OP(bSuc, break);
} while (0);
return bSuc;
}
bool CProtoGearPrice::ParseGearArr(const Json::Value &jsnRetData, ProtoAckBodyType &data)
{
CHECK_RET(warn_if_prop_not_set(jsnRetData, "GearArr"), false);
const Json::Value &jsnGearArr = jsnRetData["GearArr"];
CHECK_RET(jsnGearArr.isArray(), false);
bool bSuc = true;
int nArrSize = jsnGearArr.size();
for ( int n = 0; n < nArrSize; n++ )
{
GearPriceAckItem item;
VT_PROTO_FIELD vtField;
GetGearArrField(vtField, item);
const Json::Value jsnItem = jsnGearArr[n];
CHECK_OP(!jsnItem.isNull(), continue);
bSuc = CProtoParseBase::ParseProtoFields(jsnItem, vtField);
CHECK_OP(bSuc, break);
data.vtGear.push_back(item);
}
return bSuc;
}
static
GF_Err gdip_set_vertex_center (GF_STENCIL _this, Fixed cx, Fixed cy, u32 color)
{
GpStatus ret;
GPSTEN();
CHECK_RET(GF_STENCIL_VERTEX_GRADIENT);
if (!_sten->pRadial) return GF_BAD_PARAM;
_sten->center.X = FIX2FLT(cx);
_sten->center.Y = FIX2FLT(cy);
ret = GdipSetPathGradientCenterPoint(_sten->pRadial, &_sten->center);
ret = GdipSetPathGradientCenterColor(_sten->pRadial, (ARGB) color);
return GF_OK;
}
static
GF_Err gdip_set_radial_gradient(GF_STENCIL _this, Fixed cx, Fixed cy, Fixed fx, Fixed fy, Fixed x_radius, Fixed y_radius)
{
GPSTEN();
CHECK_RET(GF_STENCIL_RADIAL_GRADIENT);
/*store focal info*/
_sten->radius.X = FIX2FLT(x_radius);
_sten->radius.Y = FIX2FLT(y_radius);
_sten->center.X = FIX2FLT(cx);
_sten->center.Y = FIX2FLT(cy);
_sten->focal.X = FIX2FLT(fx);
_sten->focal.Y = FIX2FLT(fy);
_sten->needs_rebuild = GF_TRUE;
return GF_OK;
}
static
GF_Err gdip_set_linear_gradient (GF_STENCIL _this, Fixed start_x, Fixed start_y, Fixed end_x, Fixed end_y)
{
GPSTEN();
CHECK_RET(GF_STENCIL_LINEAR_GRADIENT);
if (_sten->pLinear) GdipDeleteBrush(_sten->pLinear);
_sten->start.X = FIX2FLT(start_x);
_sten->start.Y = FIX2FLT(start_y);
_sten->end.X = FIX2FLT(end_x);
_sten->end.Y = FIX2FLT(end_y);
GdipCreateLineBrush(&_sten->start, &_sten->end, 0xFF000000, 0xFFFFFFFF, WrapModeTile, &_sten->pLinear);
if (!_sten->pLinearMat) GdipCreateMatrix(&_sten->pLinearMat);
GdipGetLineTransform(_sten->pLinear, _sten->pLinearMat);
_sten->needs_rebuild = GF_TRUE;
return GF_OK;
}
bool CProtoQueryHKOrder::ParseJson_Ack(const Json::Value &jsnVal)
{
CHECK_RET(m_pAckData != NULL, false);
bool bSuc = true;
do
{
bSuc &= ParseProtoHead_Ack(jsnVal, m_pAckData->head);
CHECK_OP(bSuc, break);
if ( m_pAckData->head.ddwErrCode == PROTO_ERR_NO_ERROR )
{
bSuc &= ParseProtoBody_Ack(jsnVal, *m_pAckData);
CHECK_OP(bSuc, break);
}
} while (0);
return bSuc;
}
bool CProtoGearPrice::MakeJson_Ack(Json::Value &jsnVal)
{
CHECK_RET(m_pAckData != NULL, false);
bool bSuc = true;
do
{
bSuc &= MakeProtoHead_Ack(jsnVal, m_pAckData->head);
CHECK_OP(bSuc, break);
if ( m_pAckData->head.ddwErrCode == PROTO_ERR_NO_ERROR )
{
bSuc &= MakeProtoBody_Ack(jsnVal, *m_pAckData);
CHECK_OP(bSuc, break);
}
} while (0);
return bSuc;
}
bool CProtoGearPrice::MakeGearArr(Json::Value &jsnRetData, const ProtoAckBodyType &data)
{
CHECK_RET(warn_if_prop_exists(jsnRetData, "GearArr"), false);
Json::Value &jsnGearArr = jsnRetData["GearArr"];
bool bSuc = true;
for ( int n = 0; n < (int)data.vtGear.size(); n++ )
{
const GearPriceAckItem &item = data.vtGear[n];
VT_PROTO_FIELD vtField;
GetGearArrField(vtField, item);
Json::Value &jsnItem = jsnGearArr[n];
bSuc = CProtoParseBase::MakeProtoFields(jsnItem, vtField);
CHECK_OP(bSuc, break);
}
return bSuc;
}
void Sequence::AddRange(UIdType from, UIdType to)
{
CHECK_RET( from <= to, _T("invalid range in Sequence::AddRange") );
Add(from);
switch ( to - from )
{
case 0:
break;
case 1:
Add(to);
break;
default:
// don't do this - Flush() will do it later
//m_seq << ':' << to;
m_count += to - from;
m_last = to;
}
}
bool EncodeInputSurface::prepareInputBuffer()
{
int i;
int ret;
ANativeWindowBuffer* anb = NULL;
INFO("init %d input surfaces, this can take some time\n", m_bufferCount);
for (i = 0; i < m_bufferCount; i++) {
void* ptr = NULL;
anb = NULL;
ret = native_window_dequeue_buffer_and_wait(GET_ANATIVEWINDOW(mNativeWindow), &anb);
if (ret != 0) {
ERROR("native_window_dequeue_Buffer failed: (%d)\n", ret);
return false;
}
sp<GraphicBuffer> graphicBuffer = new GraphicBuffer(anb, false);
graphicBuffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN, &ptr);
DEBUG("ptr: %p, m_width: %d, m_height: %d\n", ptr, m_width, m_height);
fillSourceBuffer((uint8_t*)ptr, m_width, m_height);
graphicBuffer->unlock();
DEBUG("%d, fille anb: %p done\n", i, anb);
mBufferInfo.push(anb);
}
for (i = 0; i < 2; i++) {
anb = mBufferInfo.front();
DEBUG("cancelBuffer: %d, and: %p\n", i, anb);
ret = CAST_ANATIVEWINDOW(mNativeWindow)->cancelBuffer(GET_ANATIVEWINDOW(mNativeWindow), anb, -1);
mBufferInfo.pop();
CHECK_RET(ret, "cancelBuffer");
}
INFO("init input surface finished\n");
return true;
}
static RESULT paoxiao_use(GameContext* pGame, GameEventContext* pEvent, int player)
{
//reset attack count in this round
//pGame->players[player].params[0] = 0;
//MSG_OUT("please out a card 'sha' or cancel skill:");
RESULT ret;
//OutCardPattern pattern;
OutCard out_card;
//pattern.num = 1;
//INIT_CARDPATTERN_USE_ID(&pattern.patterns[0], CardID_Attack);
//pattern.where = PlayerCard_Hand;
ret = game_supply_card(NULL, pGame, pEvent, player, player, "h:{attack}", "please out a card 'attack' or cancel the skill:", &out_card);
CHECK_RET(ret, ret);
return game_real_out_card(pGame, pEvent, player, &out_card);
return R_SUCC;
}
static void app_desai_ad_filter_timeout_notify(handle_t Filter, const uint8_t* Section, size_t Size)
{
uint8_t filterId;
int16_t pid;
ca_filter_t filter = {0};
int32_t ret;
ret = GxDemux_FilterGetPID(Filter,&pid);
CHECK_RET(DEMUX,ret);
for (filterId= 0; filterId< MAX_FILTER_COUNT; filterId++)
{
app_porting_ca_demux_get_by_filter_id(filterId,&filter);
if (( 0 != filter.usedStatus)&&(0 != filter.handle)
&&(0 != filter.channelhandle)&&(Filter == filter.handle)&&(pid == filter.pid))
{
if(3 == filter.byReqID )
{
DSAD_CONFIG_CRC = 0;
GxDemux_FilterEnable(Filter);
}
else if(2 == filter.byReqID )
{
DSAD_DELECMD_CRC = 0;
GxDemux_FilterEnable(Filter);
}
if(gpfDataNotifyFunction[filter.byReqID])
{
//gpfDataNotifyFunction[filter.byReqID](pid,NULL,0);
}
}
}
return;
}
