void StatGroupEnableManagerCommand(FString const& InCmd) override
{
FScopeLock ScopeLock(&SynchronizationObject);
const TCHAR* Cmd = *InCmd;
if( FParse::Command(&Cmd,TEXT("list")) )
{
ListGroups();
}
else if( FParse::Command(&Cmd,TEXT("listall")) )
{
ListGroups(true);
}
else if ( FParse::Command(&Cmd,TEXT("enable")) )
{
CheckGroup(Cmd, true);
}
else if ( FParse::Command(&Cmd,TEXT("disable")) )
{
CheckGroup(Cmd, false);
}
else if ( FParse::Command(&Cmd,TEXT("none")) )
{
EnableForNewGroups = false;
UseEnableForNewGroups = true;
SetHighPerformanceEnableForAllGroups(false);
ListGroups();
}
else if ( FParse::Command(&Cmd,TEXT("all")) )
{
EnableForNewGroups = true;
UseEnableForNewGroups = true;
SetHighPerformanceEnableForAllGroups(true);
ListGroups();
}
else if ( FParse::Command(&Cmd,TEXT("default")) )
{
UseEnableForNewGroups = false;
EnableForNewGroup.Empty();
ResetHighPerformanceEnableForAllGroups();
ListGroups();
}
}
CardGroup CheckSeparateGroup(CardGroup cg, int index)
{
CardGroup cgRet;
CardGroup cg1;
cg1.baida = cg.baida;
cg1.jiang = cg.jiang;
CardGroup cg2;
cg2.baida = cg.baida;
cg2.jiang = cg.jiang;
vector< int >::iterator it;
int i = 0;
for(it = cg.cards.begin(); it != cg.cards.end(); it++)
{
// seperate cg into two small cgs
// first half and second half
if(i < index) cg1.cards.push_back(*it);
else cg2.cards.push_back(*it);
i++;
}
CardGroup tcg1 = CheckGroup(cg1);
if(tcg1.cards.size() > 0)
{
cg2.jiang = tcg1.jiang;
cg2.baida = cg.baida - tcg1.baida;
CardGroup tcg2 = CheckGroup(cg2);
if(tcg2.cards.size() > 0)
{
//cg3 is tmp value of vcg[i]+vcg2[j]
cgRet = tcg1;
cgRet.cards.insert(cgRet.cards.end(),
tcg2.cards.begin(), tcg2.cards.end());
cgRet.jiang = tcg1.jiang || tcg2.jiang;
cgRet.baida = tcg1.baida + tcg2.baida;
}
}
return cgRet;
}
bool AutoCheckManager::AutoCheck(CWnd *parent)
{
if (SiteOperationManager::IsCurrentlyChecking())
return false;
std::time_t now = time(0);
SiteItemGroup *group = GetNearestAutoCheckGroup();
if (group && (group->GetAutoCheckTime() <= now))
return CheckGroup(*group, parent);
return false;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::StopoutsFilter(const ConGroup *group)
{
if (group == NULL) return RET_OK_NONE;
m_sync.Lock();
if (CheckGroup(m_groups, group->group) == FALSE)
{
OutNonFlood(CmdOK, 180, "Stopout: not in this group [%s], should be [%s]",
group->group, m_groups);
m_sync.Unlock();
return RET_OK_NONE;
}
m_sync.Unlock();
return RET_OK;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::ProcessStopApply(TradeRecord *trade,
const ConGroup *group, const int isTP)
{
char *groupStr = new char[50];
strcpy(groupStr, group->group);
if (CheckGroup(m_groups, groupStr) == FALSE)
{
delete []groupStr;
return FALSE;
}
delete []groupStr;
double price = 0;
// получим текущие цены для группы и установки символа
double prices[2] = { 0, 0 };
int orderSide = trade->cmd == OP_BUY ? 1 : 0;
if (ExtServer->HistoryPricesGroup(trade->symbol, group, prices) == RET_OK)
{
int orderSide = trade->cmd == OP_BUY ? 0 : 1; // меняется от знака сделки
price = prices[orderSide];
}
CharString strMsg;
strMsg.Printf(FALSE, "%s (%s at %g) is applying to order %d",
isTP ? "TP" : "SL",
orderSide == 1 ? "BUY" : "SELL",
price,
trade->order);
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, strMsg.ToArray());
SLTPOrderRequest req = { trade->order, price };
m_orderRequests.Enqueue(&req);
// отправить запрос на сервер
int requestId = m_nextStopRequestId++;
strMsg.Printf(FALSE, "requestId=%d;type=%s;price=%g;login=%d;symbol=%s;volume=%d;",
trade->order,
isTP ? "TP" : "SL",
price,
trade->login,
trade->symbol,
trade->volume);
m_sender->SendTo(&strMsg, m_sendHost, m_sendPort);
return TRUE;
}
void InitCheckGroup(__in HWND hwnd, __in int idCheckbox, __in int idGroupbox)
{
RECT rc;
HWND hwndCheckbox= GetDlgItem(hwnd, idCheckbox);
HWND hwndGroup = GetDlgItem(hwnd, idGroupbox);
POINT newCheckboxPlace;
/* Clear the groupbox text */
SetDlgItemText(hwnd, idGroupbox, TEXT(""));
/* get groupbox coordinates */
GetWindowRect(hwndGroup, &rc);
newCheckboxPlace.x = rc.left;
newCheckboxPlace.y = rc.top;
ScreenToClient(hwnd, &newCheckboxPlace);
GetClientRect(hwndCheckbox, &rc);
// Move the checkbox on top of the groupbox
SetWindowPos(hwndCheckbox, hwndGroup,
newCheckboxPlace.x+8, newCheckboxPlace.y,
rc.right, rc.bottom,
0);
CheckGroup(hwnd, idCheckbox, idGroupbox);
}
static int
XkbRF_CheckApplyRule( XkbRF_RulePtr rule,
XkbRF_MultiDefsPtr mdefs,
XkbComponentNamesPtr names,
XkbRF_RulesPtr rules)
{
Bool pending = FALSE;
if (rule->model != NULL) {
if(mdefs->model == NULL)
return 0;
if (strcmp(rule->model, "*") == 0) {
pending = TRUE;
} else {
if (rule->model[0] == '$') {
if (!CheckGroup(rules, rule->model, mdefs->model))
return 0;
} else {
if (strcmp(rule->model, mdefs->model) != 0)
return 0;
}
}
}
if (rule->option != NULL) {
if (mdefs->options == NULL)
return 0;
if ((!MatchOneOf(rule->option,mdefs->options)))
return 0;
}
if (rule->layout != NULL) {
if(mdefs->layout[rule->layout_num] == NULL ||
*mdefs->layout[rule->layout_num] == '\0')
return 0;
if (strcmp(rule->layout, "*") == 0) {
pending = TRUE;
} else {
if (rule->layout[0] == '$') {
if (!CheckGroup(rules, rule->layout,
mdefs->layout[rule->layout_num]))
return 0;
} else {
if (strcmp(rule->layout, mdefs->layout[rule->layout_num]) != 0)
return 0;
}
}
}
if (rule->variant != NULL) {
if (mdefs->variant[rule->variant_num] == NULL ||
*mdefs->variant[rule->variant_num] == '\0')
return 0;
if (strcmp(rule->variant, "*") == 0) {
pending = TRUE;
} else {
if (rule->variant[0] == '$') {
if (!CheckGroup(rules, rule->variant,
mdefs->variant[rule->variant_num]))
return 0;
} else {
if (strcmp(rule->variant,
mdefs->variant[rule->variant_num]) != 0)
return 0;
}
}
}
if (pending) {
rule->flags|= XkbRF_PendingMatch;
return rule->number;
}
/* exact match, apply it now */
XkbRF_ApplyRule(rule,names);
return rule->number;
}
INT_PTR CALLBACK OptionDialogProc(__in HWND hwndDlg, __in UINT uMsg, __in WPARAM wParam, __in LPARAM lParam)
{
switch(uMsg)
{
case WM_INITDIALOG:
/* initialize check box*/
SendDlgItemMessage(hwndDlg, IDC_CHK_ENABLE,
BM_SETCHECK,
g_EnableOllyCapstone ? BST_CHECKED : BST_UNCHECKED, 0);
SendDlgItemMessage(hwndDlg, IDC_CHK_DISASSEMBLE_IN_LOWERCASE,
BM_SETCHECK,
*g_pDisasmLowercase ? BST_CHECKED : BST_UNCHECKED, 0);
InitCheckGroup(hwndDlg, IDC_CHK_ENABLE, IDC_SYNTAX);
/* Initialize radio buttons */
switch(g_Syntax)
{
case OLLY_CAPSTONE_MODE_SYNTAX_INTEL:
SendDlgItemMessage(hwndDlg, IDC_RD_INTEL, BM_SETCHECK, BST_CHECKED, 0);
break;
case OLLY_CAPSTONE_MODE_SYNTAX_ATT:
SendDlgItemMessage(hwndDlg, IDC_RD_ATT, BM_SETCHECK, BST_CHECKED, 0);
break;
}
break;
case WM_COMMAND:
switch(wParam)
{
case IDC_CHK_ENABLE: /* "Enable" checkbox */
g_EnableOllyCapstone = (BST_CHECKED ==
SendDlgItemMessage(hwndDlg, IDC_CHK_ENABLE, BM_GETCHECK, 0, 0));
CheckGroup(hwndDlg, IDC_CHK_ENABLE, IDC_SYNTAX);
UpdateAsmWnd();
break;
case IDC_CHK_DISASSEMBLE_IN_LOWERCASE: /* "Lowercase" checkbox */
*g_pDisasmLowercase = (BST_CHECKED ==
SendDlgItemMessage(hwndDlg, IDC_CHK_DISASSEMBLE_IN_LOWERCASE, BM_GETCHECK, 0, 0));
UpdateAsmWnd();
break;
case IDC_RD_ATT:
if (BST_CHECKED == SendDlgItemMessage(hwndDlg, IDC_RD_ATT, BM_GETCHECK, 0, 0))
{
g_Syntax = OLLY_CAPSTONE_MODE_SYNTAX_ATT;
UpdateAsmWnd();
}
break;
case IDC_RD_INTEL:
if (BST_CHECKED == SendDlgItemMessage(hwndDlg, IDC_RD_INTEL, BM_GETCHECK, 0, 0))
{
g_Syntax = OLLY_CAPSTONE_MODE_SYNTAX_INTEL;
UpdateAsmWnd();
}
break;
case IDCANCEL: /*press ESC*/
case IDC_BTN_CLOSE: /* click "Close" button */
PostMessage(hwndDlg, WM_CLOSE, 0, 0);
break;
default:
return FALSE;
}
break;
case WM_CLOSE:
EndDialog(hwndDlg, 0);
break;
default:
return FALSE;
}
return TRUE;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::StopoutsApply(const UserInfo *user, const ConGroup *group,
const char *comment)
{
Out(CmdOK, "CProcessor::StopoutsApply - Applying stopout for user [%d]", user->login);
TradeRecord *trades,*trade;
int total, i;
ConSymbol symbol = {0};
TradeTransInfo trans = {0};
time_t currtime;
char stopout[64] = "[stopout]";
const char *cp;
// check
if (user == NULL || group == NULL || comment == NULL)
{
Out(CmdOK, "CProcessor::StopoutsApply - check failed");
return RET_OK;
}
// lock
m_sync.Lock();
// check user group
if (CheckGroup(m_groups, group->group) == FALSE)
{
Out(CmdOK, "CProcessor::StopoutsApply - group check failed");
m_sync.Unlock();
return(RET_OK);
}
// receive all opened trades for user
if ((trades = ExtServer->OrdersGetOpen(user, &total)) == NULL)
{
Out(CmdOK, "CProcessor::StopoutsApply - no open trade");
return RET_OK;
}
// get current server time
currtime = ExtServer->TradeTime();
// prepare comment about stopout
if ((cp = strrchr(comment, '[')) != NULL) COPY_STR(stopout, cp);
// output to server log
Out(CmdOK, "'%d': close all orders due stop out %s", user->login, stopout);
// go trough trades
for (i = 0, trade = trades; i < total; i++, trade++)
{
// it is opened trade
if (trade->cmd > OP_SELL) continue;
// check symbol - зачем?
// if (CheckGroup(m_symbols, trade->symbol) == FALSE) continue;
// check volume - зачем?
// if (m_max_volume != 0 && trade->volume > m_max_volume) continue;
// receive symbol information
if (ExtServer->SymbolsGet(trade->symbol, &symbol) == FALSE)
{
Out(CmdAtt, "stopout: receiving information for %s symbol failed", trade->symbol);
continue;
}
// check trade session for symbol
if (ExtServer->TradesCheckSessions(&symbol, currtime) == FALSE) continue;
// prepare transaction
trans.order = trade->order;
trans.price = trade->close_price;
trans.volume = trade->volume;
trans.type = TT_ORDER_MK_CLOSE; // !
// prepare comment
if (trade->comment[0] != 0)
{
COPY_STR(trans.comment, trade->comment);
if (strstr(trans.comment, stopout) == NULL)
_snprintf(trans.comment, sizeof(trans.comment) - 1, "%s %s", trans.comment, "[stopout FXI]");
}
else
COPY_STR(trans.comment, stopout);
// отправить запрос на закрытие позиции на сервер
// создать запрос
RequestInfo inf = { 0 };
memcpy(&(inf.trade), &trans, sizeof(TradeTransInfo));
inf.login = user->login;
inf.id = trade->order; // startStopoutRequestId++; // !!
memcpy(&inf.group, &group->group, sizeof(inf.group));
memcpy(&inf.trade.symbol, &trade->symbol, sizeof(trade->symbol));
// добавить в очередь
Add(&inf, TRUE);
}
m_sync.Unlock();
// free memory
HEAP_FREE(trades);
// сервер больше не процессит стопаут
return RET_OK_NONE;
}
int CProcessor::Add(const UserInfo *user, const ConGroup *group, const ConSymbol *symbol,
const TradeRecord *pending, TradeRecord *trade)
{
Request *temp;
UINT id;
static int uid = 1;
CharString str;
if (pending == NULL || trade == NULL) return(FALSE);
// проверки - кто управляет счетом
if (m_delay == 0 || CheckGroup(m_groups, group->group) == FALSE)
return (TRUE);
double prices[2];
// получим текущие цены для группы и установки символа
if (ExtServer->HistoryPricesGroup(symbol->symbol, group, prices) != RET_OK)
{
str.Printf(FALSE, "CProcessor::Add Pending (symbol [%s], group [%s]) failed", symbol->symbol, group->group);
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, str.ToArray());
return FALSE;
}
m_sync.Lock();
// проверить - нет ли такого запроса в списке
Request *reqTmp;
if (m_requests != NULL)
{
int i = 0;
for (reqTmp = m_requests; i < m_requests_total; i++, reqTmp++)
{
if (reqTmp->isPending)
if (reqTmp->pendingId == pending->order)
{
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, "Отложенный ордер уже в списке");
m_sync.Unlock();
return (TRUE);
}
}
}
// лог
/*char reqCmdStr[64];
FormatCommand(pending->cmd, reqCmdStr);
str.Printf(FALSE, "CProcessor::Add Pending(order [%d], cmd [%s], req Id [%d])",
pending->order, reqCmdStr, startPendingRequestId);
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, str.ToArray());*/
//---- если место для запросов нет выделим
if(m_requests == NULL)
{
if((m_requests = new Request[256]) == NULL)
{
m_sync.Unlock();
return (FALSE);
}
m_requests_max = 256;
m_requests_total = 0;
}
//---- посмотрим может надо перевыделить
if (m_requests_total >= m_requests_max)
{
if((temp = new Request[m_requests_max + 256]) == NULL)
{
m_sync.Unlock();
return(FALSE);
}
//---- скопируем старое
memcpy(temp, m_requests, sizeof(Request) * m_requests_total);
//---- удалим уже не нужное
delete m_requests;
m_requests = temp;
m_requests_max += 256;
}
//---- вставляем запрос
m_requests[m_requests_total].pendingId = pending->order;
m_requests[m_requests_total].isPending = TRUE;
m_requests[m_requests_total].id = startPendingRequestId++;
m_requests[m_requests_total].time = GetTickCount();
m_requests[m_requests_total].sent = FALSE;
m_requests[m_requests_total].login = user->login;
memcpy(&m_requests[m_requests_total].trans, pending, sizeof(TradeTransInfo));
m_requests[m_requests_total].trans.volume = trade->volume;
Out(CmdOK, "Pending order %d added of volume %d",
m_requests[m_requests_total].id, trade->volume);
COPY_STR(m_requests[m_requests_total].group, group->group);
// поправить команду
char origTradeCmd[32], newTradeCmd[32];
FormatCommand(m_requests[m_requests_total].trans.cmd, origTradeCmd);
int pendCmd = trade->cmd; //m_requests[m_requests_total].trans.cmd;
pendCmd = (pendCmd == OP_BUY_LIMIT || pendCmd == OP_BUY_STOP) ? OP_BUY
: (pendCmd == OP_SELL_LIMIT || pendCmd == OP_SELL_STOP) ? OP_SELL
: pendCmd;
m_requests[m_requests_total].trans.cmd = pendCmd;
FormatCommand(m_requests[m_requests_total].trans.cmd, newTradeCmd);
m_requests[m_requests_total].trans.type = TT_ORDER_MK_OPEN;
m_requests[m_requests_total].trans.price = pendCmd == OP_BUY ? prices[1] : prices[0];
strcpy(m_requests[m_requests_total].trans.symbol, symbol->symbol);
m_requests[m_requests_total].trans.order = pending->order;
str.Printf(FALSE, "Отложенный ордер %d добавлен, всего %d (%s, теперь %s)",
pending->order, m_requests_total, origTradeCmd, newTradeCmd);
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, str.ToArray());
m_requests_total++;
//---- запускаем поток
if (m_thread == NULL)
if ((m_thread = (HANDLE)_beginthreadex(NULL, 256000, ThreadFunction, this, 0, &id))==NULL)
{
m_sync.Unlock();
return(FALSE);
}
m_sync.Unlock();
return(TRUE);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::Add(RequestInfo *request, int isStopout)
{
Request *temp;
UINT id;
Request req = {0};
static int uid = 1;
if (request == NULL) return(FALSE);
// проверки - кто управляет счетом
if (m_delay == 0 || CheckGroup(m_groups, request->group) == FALSE)
return (TRUE);
// лог
char reqTypeStr[64];
char reqCmdStr[64];
FormatCommand(request->trade.cmd, reqCmdStr);
FormatRequestType(request->trade.type, reqTypeStr);
CharString str;
str.Printf(FALSE, "CProcessor::Add(тип [%s], cmd [%s])", reqTypeStr, reqCmdStr);
ExtServer->LogsOut(CmdOK, PROGRAM_TITLE, str.ToArray());
m_sync.Lock();
//---- если место для запросов нет выделим
if(m_requests == NULL)
{
if((m_requests = new Request[256]) == NULL)
{
m_sync.Unlock();
return (FALSE);
}
m_requests_max = 256;
m_requests_total = 0;
}
//---- посмотрим может надо перевыделить
if (m_requests_total >= m_requests_max)
{
if((temp = new Request[m_requests_max + 256]) == NULL)
{
m_sync.Unlock();
return(FALSE);
}
//---- скопируем старое
memcpy(temp, m_requests, sizeof(Request) * m_requests_total);
//---- удалим уже не нужное
delete m_requests;
m_requests = temp;
m_requests_max += 256;
}
//---- вставляем запрос
m_requests[m_requests_total].isStopout = isStopout;
m_requests[m_requests_total].isPending = FALSE;
m_requests[m_requests_total].id = request->id;
m_requests[m_requests_total].time = GetTickCount();
m_requests[m_requests_total].sent = FALSE;
m_requests[m_requests_total].login = request->login;
memcpy(&m_requests[m_requests_total].trans, &request->trade, sizeof(TradeTransInfo));
COPY_STR(m_requests[m_requests_total].group, request->group);
m_requests_total++;
//---- запускаем поток
if (m_thread == NULL)
if ((m_thread = (HANDLE)_beginthreadex(NULL, 256000, ThreadFunction, this, 0, &id))==NULL)
{
m_sync.Unlock();
return(FALSE);
}
m_sync.Unlock();
return(TRUE);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::IsGroupEnabled(const char *group)
{
return CheckGroup(m_groups, group);
}
/*
* Determines the id of the group the specified
* item belongs to.
*/
int CShellBrowser::DetermineItemGroup(int iItemInternal)
{
PFNLVGROUPCOMPARE pfnGroupCompare = NULL;
TCHAR szGroupHeader[512];
int iGroupId;
switch(m_SortMode)
{
case FSM_NAME:
DetermineItemNameGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_TYPE:
DetermineItemTypeGroupVirtual(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_SIZE:
DetermineItemSizeGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_DATEMODIFIED:
DetermineItemDateGroup(iItemInternal,GROUP_BY_DATEMODIFIED,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_TOTALSIZE:
DetermineItemTotalSizeGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_FREESPACE:
DetermineItemFreeSpaceGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = FreeSpaceComparison;
break;
case FSM_DATEDELETED:
break;
case FSM_ORIGINALLOCATION:
break;
case FSM_ATTRIBUTES:
DetermineItemAttributeGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_SHORTNAME:
DetermineItemNameGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_OWNER:
DetermineItemOwnerGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_PRODUCTNAME:
DetermineItemVersionGroup(iItemInternal,_T("ProductName"),szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_COMPANY:
DetermineItemVersionGroup(iItemInternal,_T("CompanyName"),szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_DESCRIPTION:
DetermineItemVersionGroup(iItemInternal,_T("FileDescription"),szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_FILEVERSION:
DetermineItemVersionGroup(iItemInternal,_T("FileVersion"),szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_PRODUCTVERSION:
DetermineItemVersionGroup(iItemInternal,_T("ProductVersion"),szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_SHORTCUTTO:
break;
case FSM_HARDLINKS:
break;
case FSM_EXTENSION:
DetermineItemExtensionGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_CREATED:
DetermineItemDateGroup(iItemInternal,GROUP_BY_DATECREATED,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_ACCESSED:
DetermineItemDateGroup(iItemInternal,GROUP_BY_DATEACCESSED,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_TITLE:
DetermineItemSummaryGroup(iItemInternal,&SCID_TITLE,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_SUBJECT:
DetermineItemSummaryGroup(iItemInternal,&SCID_SUBJECT,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_AUTHOR:
DetermineItemSummaryGroup(iItemInternal,&SCID_AUTHOR,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_KEYWORDS:
DetermineItemSummaryGroup(iItemInternal,&SCID_KEYWORDS,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_COMMENTS:
DetermineItemSummaryGroup(iItemInternal,&SCID_COMMENTS,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_CAMERAMODEL:
DetermineItemCameraPropertyGroup(iItemInternal,PropertyTagEquipModel,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_DATETAKEN:
DetermineItemCameraPropertyGroup(iItemInternal,PropertyTagDateTime,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_WIDTH:
DetermineItemCameraPropertyGroup(iItemInternal,PropertyTagImageWidth,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_HEIGHT:
DetermineItemCameraPropertyGroup(iItemInternal,PropertyTagImageHeight,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_VIRTUALCOMMENTS:
break;
case FSM_FILESYSTEM:
DetermineItemFileSystemGroup(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
case FSM_NUMPRINTERDOCUMENTS:
break;
case FSM_PRINTERSTATUS:
break;
case FSM_PRINTERCOMMENTS:
break;
case FSM_PRINTERLOCATION:
break;
case FSM_NETWORKADAPTER_STATUS:
DetermineItemNetworkStatus(iItemInternal,szGroupHeader,SIZEOF_ARRAY(szGroupHeader));
pfnGroupCompare = NameComparison;
break;
default:
assert(false);
break;
}
iGroupId = CheckGroup(szGroupHeader,pfnGroupCompare);
return iGroupId;
}
bool CardPlayer::checkHu()
{
CardGroup cg;
CardGroup tiao;
CardGroup bing;
CardGroup wan;
CardGroup tcg;
cg.jiang = false;
cg.baida = m_MyPAIVec[MJTYPE_BAIDA].size();
depth = 0;
if(m_MyPAIVec[MJTYPE_TIAO].size() > 0)
{
cg.type = MJTYPE_TIAO;
cg.cards = m_MyPAIVec[MJTYPE_TIAO];
tcg = CheckGroup(cg);
//printf("tcg size TIAO: %d\n", tcg.cards.size());
if(tcg.cards.size() <= 0)
{
return false;
}
cg.jiang |= tcg.jiang;
cg.baida -= tcg.baida;
tiao = tcg;
}
if(m_MyPAIVec[MJTYPE_BING].size() > 0)
{
cg.type = MJTYPE_BING;
cg.cards = m_MyPAIVec[MJTYPE_BING];
//debug = 1;
tcg = CheckGroup(cg);
//printf("tcg size BING: %d\n", tcg.cards.size());
//debug = 0;
if(tcg.cards.size() <= 0)
{
return false;
}
cg.jiang |= tcg.jiang;
cg.baida -= tcg.baida;
bing = tcg;
}
if(m_MyPAIVec[MJTYPE_WAN].size() > 0)
{
cg.type = MJTYPE_WAN;
cg.cards = m_MyPAIVec[MJTYPE_WAN];
tcg = CheckGroup(cg);
//printf("tcg size WAN: %d\n", tcg.cards.size());
if(tcg.cards.size() <= 0)
{
return false;
}
cg.jiang |= tcg.jiang;
cg.baida -= tcg.baida;
wan = tcg;
}
m_tiao = tiao;
m_bing = bing;
m_wan = wan;
//vector< int >::iterator it;
printf("call depth is %d\n", depth);
return true;
}
