// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCFindFirstItem
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCFindFirstItem::COp_KCFindFirstItem()
:mAttrList("AttributeList")
{
AddParam(mKeychainIndex);
AddParam(mAttrList);
AddResult(mSearchIndex);
AddResult(mItemIndex);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCGetData
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCGetData::COp_KCGetData()
:mData("Data"),
mActualLength("ActualLength")
{
AddParam(mItemIndex);
AddParam(mData);
AddResult(mData);
AddResult(mActualLength);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCGetAttribute
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCGetAttribute::COp_KCGetAttribute()
:mAttribute("Attribute"),
mActualLength("ActualLength")
{
AddParam(mItemIndex);
AddParam(mAttribute);
AddResult(mAttribute);
AddResult(mActualLength);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCFindGenericPassword
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCFindGenericPassword::COp_KCFindGenericPassword()
:mServiceName("ServiceName"),
mAccountName("AccountName"),
mPassword("Password"),
mActualLength("ActualLength")
{
AddParam(mServiceName);
AddParam(mAccountName);
AddParam(mPassword);
AddResult(mPassword);
AddResult(mActualLength);
AddResult(mItemIndex);
}
void SearchMore()
{
u32 i;
int MSize=1<<Size;
u64 cto=CompareValue;
u64 val;
u64 old;
int addr;
std::vector<result> oldr=std::vector<result>(results);
results.clear();
for(i=0;i<oldr.size();i++)
{
val =0;
addr=oldr[i].address;
memcpy(&val,mptr[Source]+addr,MSize);
memcpy(&old,olds+addr,MSize);
if(CompareTo==0)
{
cto=old;
}
if(CompareAny(val,cto)) {
AddResult(addr);
UpdateStatus();
}
}
}
void npoint_mlpack::UnorderedEfficientMultiMatcher::ComputeBaseCase(NodeTuple& nodes) {
PartialResult this_result(results_size_);
ComputeBaseCase(nodes, this_result);
AddResult(this_result);
} // ComputeBaseCase
void SearchFirst()
{
int MSize=1<<Size;
u64*cur=(u64*)mptr[Source];
u64 cto=CompareValue;
u64 val;
u64 old;
int addr;
addr=0;
while((addr+MSize)<msize[Source])
{
(u64)val=0;
memcpy(&val,cur,MSize); //update the buffer
memcpy(&old,olds+addr,MSize); //
if(CompareTo==0)
{
cto=old;
}
if(CompareAny(val,cto)) {
AddResult(addr);
cur=(u64*)(((char*)cur)+MSize);
addr+=MSize;
UpdateStatus();
}
else {
cur=(u64*)(((char*)cur)+1);
addr+=1;
}
}
FirstSearch=false;
}
//
// OPERATION: AddResultAndLoopControl
//
// DESCRIPTION: AddResultAndLoopControl
//
zOPER_EXPORT zLONG OPERATION
AddResultAndLoopControlToView( zVIEW vSubtask,
zVIEW vTargetView,
zPCHAR pchCompareValue,
zLONG lVariableID,
zLONG lOperator,
zPCHAR pchConstantValue )
{
zLONG lResultID;
lResultID = AddResult( vSubtask );
AddExprNodeEntityToView( vSubtask, vTargetView, qVARIABLE, qNUMERIC,
qTSHORT, "", lResultID, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, qNUMERIC,
qTINTEGER, "CONDEQUAL", qCONDEQUAL, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qCONSTANT, qNUMERIC,
qTINTEGER, pchCompareValue, 0, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, qNUMERIC,
qTINTEGER, "AND", qAND, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qVARIABLE, qNUMERIC,
qTINTEGER, "", lVariableID, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, qNUMERIC,
qTINTEGER, "", lOperator, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qCONSTANT, qNUMERIC,
qTINTEGER, pchConstantValue, 0, 0 );
return( 0 );
}
double RangeSearchRules<MetricType, TreeType>::Score(const size_t queryIndex,
TreeType& referenceNode)
{
// We must get the minimum and maximum distances and store them in this
// object.
math::Range distances;
if (tree::TreeTraits<TreeType>::FirstPointIsCentroid)
{
// In this situation, we calculate the base case. So we should check to be
// sure we haven't already done that.
double baseCase;
if (tree::TreeTraits<TreeType>::HasSelfChildren &&
(referenceNode.Parent() != NULL) &&
(referenceNode.Point(0) == referenceNode.Parent()->Point(0)))
{
// If the tree has self-children and this is a self-child, the base case
// was already calculated.
baseCase = referenceNode.Parent()->Stat().LastDistance();
lastQueryIndex = queryIndex;
lastReferenceIndex = referenceNode.Point(0);
}
else
{
// We must calculate the base case by hand.
baseCase = BaseCase(queryIndex, referenceNode.Point(0));
}
// This may be possibly loose for non-ball bound trees.
distances.Lo() = baseCase - referenceNode.FurthestDescendantDistance();
distances.Hi() = baseCase + referenceNode.FurthestDescendantDistance();
// Update last distance calculation.
referenceNode.Stat().LastDistance() = baseCase;
}
else
{
distances = referenceNode.RangeDistance(querySet.unsafe_col(queryIndex));
}
// If the ranges do not overlap, prune this node.
if (!distances.Contains(range))
return DBL_MAX;
// In this case, all of the points in the reference node will be part of the
// results.
if ((distances.Lo() >= range.Lo()) && (distances.Hi() <= range.Hi()))
{
AddResult(queryIndex, referenceNode);
return DBL_MAX; // We don't need to go any deeper.
}
// Otherwise the score doesn't matter. Recursion order is irrelevant in
// range search.
return 0.0;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCFindAppleSharePassword
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCFindAppleSharePassword::COp_KCFindAppleSharePassword()
:mServerSignature("ServerSignature"),
mServerAddress("ServerAddress"),
mServerName("ServerName"),
mVolumeName("VolumeName"),
mAccountName("AccountName"),
mPassword("Password"),
mActualLength("ActualLength")
{
AddParam(mServerSignature);
AddParam(mServerAddress);
AddParam(mServerName);
AddParam(mVolumeName);
AddParam(mAccountName);
AddParam(mPassword);
AddResult(mPassword);
AddResult(mActualLength);
AddResult(mItemIndex);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCNewItem
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCNewItem::COp_KCNewItem()
:mItemClass("Class"),
mItemCreator("Creator"),
mData("Data")
{
AddParam(mItemClass);
AddParam(mItemCreator);
AddParam(mData);
AddResult(mItemIndex);
}
void SFlareSkirmishScoreMenu::FillResults(TSharedPtr<SVerticalBox> Box, FText Title, FFlareSkirmishPlayerResult Result)
{
const FFlareStyleCatalog& Theme = FFlareStyleSet::GetDefaultTheme();
// Title
Box->AddSlot()
.AutoHeight()
.HAlign(HAlign_Left)
.Padding(Theme.TitlePadding)
[
SNew(STextBlock)
.Text(Title)
.TextStyle(&Theme.SubTitleFont)
];
// Results
AddResult(Box, LOCTEXT("ResultDisabled", "Ships disabled"), Result.ShipsDisabled);
AddResult(Box, LOCTEXT("ResultDestroyed", "Ships destroyed"), Result.ShipsDestroyed);
AddResult(Box, LOCTEXT("ResultFired", "Projectiles fired"), Result.AmmoFired);
AddResult(Box, LOCTEXT("ResultHit", "Successful hits"), Result.AmmoHit);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCFindInternetPassword
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCFindInternetPassword::COp_KCFindInternetPassword()
:mServerName("ServerName"),
mSecurityDomain("SecurityDomain"),
mAccountName("AccountName"),
mPort("Port"),
mProtocol("Protocol"),
mAuthType("AuthType"),
mPassword("Password"),
mActualLength("ActualLength")
{
AddParam(mServerName);
AddParam(mSecurityDomain);
AddParam(mAccountName);
AddParam(mPort);
AddParam(mProtocol);
AddParam(mAuthType);
AddParam(mPassword);
AddResult(mPassword);
AddResult(mActualLength);
AddResult(mItemIndex);
}
SlimList* ListExecutor::Execute(SlimList* instructions)
{
SlimList* results = new SlimList();
int numberOfInstructions = instructions->GetLength();
for (int n = 0; n < numberOfInstructions; ++n)
{
SlimList* instruction = instructions->GetListAt(n);
std::string id = instruction->GetStringAt(0);
std::string result = Dispatch(instruction);
AddResult(results, id, result.c_str());
}
return results;
}
SlimList* ListExecutor_Execute(ListExecutor* self, SlimList* instructions)
{
SlimList* results = SlimList_Create();
int numberOfInstructions = SlimList_GetLength(instructions);
int n;
for (n=0; n<numberOfInstructions; n++) {
SlimList* instruction = SlimList_GetListAt(instructions, n);
char* id = SlimList_GetStringAt(instruction, 0);
char* result = Dispatch(self, instruction);
AddResult(results, id, result);
if (result)
free(result);
}
return results;
}
//
// OPERATION: AddResultCondEqual
//
// e.g. if ( RESULT > zCURSOR_UNCHANGED )
//
zOPER_EXPORT zLONG OPERATION
AddResultCondEqual( zVIEW vSubtask,
zLONG lStatementType,
zPCHAR pchCompareValue )
{
zLONG lResultID;
zLONG lDefineZKey;
zLONG lVarDataType;
zVIEW vTargetView;
CreateEntity( g_lpExprView, "Expression", zPOS_AFTER );
CreateViewFromViewForTask( &vTargetView, g_lpExprView, 0 );
// Insert new bottom of stack.
AddOperatorToView( vSubtask, vTargetView, -2 );
lResultID = AddResult( vSubtask );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, 0,
qTINTEGER, "(", qLPAREN, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qVARIABLE, qNUMERIC,
qTSHORT, "", lResultID, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, qNUMERIC,
qTINTEGER, ">", qGREATERTHAN, 0 );
lDefineZKey = GetDefineZKey( vSubtask, &lVarDataType, pchCompareValue );
AddExprNodeEntityToView( vSubtask, vTargetView, qDEFINE, qZEIDONOPERATION,
qTINTEGER, pchCompareValue, lDefineZKey, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, 0,
qTINTEGER, ")", qRPAREN, 0 );
// Dump the expression from the stack.
AddOperatorToView( vSubtask, vTargetView, -1 );
AddStatementEntityToPI( vSubtask, lStatementType, qqlineno, vTargetView, zPOS_AFTER );
DeleteEntity( vTargetView, "Expression", zREPOS_NONE );
DropView( vTargetView );
return( 0 );
}
//
// OPERATION: AddResultCondExpr
//
// DESCRIPTION: AddResultCondExpr
//
zOPER_EXPORT zLONG OPERATION
AddResultCondExprToView( zVIEW vSubtask,
zVIEW vTargetView,
zLONG lOperator,
zPCHAR pchCompareValue )
{
zLONG lResultID;
// zCHAR szConstant[ 31 ];
zLONG lDefineZKey;
zLONG lVarDataType;
lResultID = AddResult( vSubtask );
AddExprNodeEntityToView( vSubtask, vTargetView, qVARIABLE, qNUMERIC,
qTSHORT, "ResultID", lResultID, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qOPERATOR, qNUMERIC,
qTINTEGER, "", lOperator, 0 );
#if 0
// Convert the Define value passed into a constant.
SetCursorFirstEntityByString( g_lpSGView, "DefinedItem", "ExternalValue",
pchCompareValue, "VML_XSource" );
GetVariableFromAttribute( szConstant, 0, zTYPE_STRING, 30,
g_lpSGView, "DefinedItem", "InternalValue", 0, 0 );
AddExprNodeEntityToView( vSubtask, vTargetView, qCONSTANT,
qNUMERIC, qTINTEGER, szConstant, 0, 0 );
#endif
lDefineZKey = GetDefineZKey( vSubtask, &lVarDataType, pchCompareValue );
AddExprNodeEntityToView( vSubtask, vTargetView, qDEFINE, qZEIDONOPERATION,
qTINTEGER, pchCompareValue, lDefineZKey, 0 );
// SetNameForView( vTargetView, "***TargetView", vSubtask, zLEVEL_TASK );
// IssueError( vSubtask, 0, 0, "AddResultCondExprToView" );
return( 0 );
}
void CDissolveDialog::RemoveResult(const ITEMBASE& sourceItem)
{
ResultContainer resultContainer;
GetDissolvedResult(
sourceItem,
resultContainer);
ResultContainer remainedResultContainer;
for(BYTE tabIndex = 0; tabIndex < GetTabNum(); ++tabIndex)
{
cPushupButton* const button = GetTabBtn(
tabIndex);
if(FALSE == button->IsActive())
{
break;
}
cIconGridDialog* const iconGridDialog = (cIconGridDialog*)GetTabSheet(
tabIndex);
for(WORD cellIndex = 0; cellIndex < iconGridDialog->GetCellNum(); ++cellIndex)
{
CItem* const item = (CItem*)iconGridDialog->GetIconForIdx(
cellIndex);
const ResultContainer::iterator iterator = resultContainer.find(
item->GetItemIdx());
if(resultContainer.end() == iterator)
{
continue;
}
const DURTYPE quantity = iterator->second;
if(item->GetDurability() <= quantity)
{
Clear(
*item);
}
else
{
item->SetDurability(
item->GetDurability() - quantity);
}
}
}
ResultContainer randomResultContainer;
GetDissolvedResult(
sourceItem,
randomResultContainer);
// 랜덤 결과를 제거한다
for(ResultContainer::const_iterator iterator = randomResultContainer.begin();
randomResultContainer.end() != iterator;
++iterator)
{
const ItemIndex itemIndex = iterator->first;
const ItemQuantity itemQuantity = iterator->second;
for(WORD cellIndex = 0; mRandomResultDialog->GetCellNum() > cellIndex; ++cellIndex)
{
CItem* const item = (CItem*)mRandomResultDialog->GetIconForIdx(
cellIndex);
if(item->GetItemIdx() != itemIndex)
{
continue;
}
else if(item->GetDurability() <= DURTYPE(itemQuantity))
{
Clear(
*item);
break;
}
item->SetDurability(
item->GetDurability() - itemQuantity);
break;
}
}
// 결과를 재배치한다
{
ClearResult();
for(WORD cellIndex = 0; mSourceDialog->GetCellNum() > cellIndex; ++cellIndex)
{
CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
cellIndex);
if(item->GetDBIdx() == sourceItem.dwDBIdx)
{
continue;
}
AddResult(
item->GetItemBaseInfo());
}
}
// 현재 탭이 숨겨질 경우, 그 이전 탭으로 변경해야한다
{
cPushupButton* const button = GetTabBtn(
GetCurTabNum());
if(FALSE == button->IsActive())
{
SelectTab(
BYTE(max(int(GetCurTabNum()) - 1, 0)));
}
}
}
// 100625 ONS 분해시 우클릭으로 아이템이동 가능하도록 수정.
void CDissolveDialog::MoveIcon( CItem* movedItem )
{
// 완료된 결과가 있을 경우 초기화시킨다
{
CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
0);
if(item->IsLocked())
{
Clear();
}
}
if( 0 == movedItem )
{
return;
}
else if(WT_ITEM != movedItem->GetType())
{
return;
}
else if(movedItem->IsLocked())
{
return;
}
else if(FALSE == ITEMMGR->IsEqualTableIdxForPos(eItemTable_Inventory, movedItem->GetPosition()))
{
CHATMGR->AddMsg(
CTC_SYSMSG,
CHATMGR->GetChatMsg(787));
return;
}
const Error error = IsEnableUpdate(movedItem->GetItemBaseInfo());
if(ErrorNone != error)
{
PutError(
error,
movedItem->GetItemIdx());
return;
}
WORD wEmptyPos = 0;
for(WORD cellIndex = 0; mSourceDialog->GetCellNum() > cellIndex; ++cellIndex)
{
CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
cellIndex);
if(0 == item->GetItemIdx())
{
wEmptyPos = cellIndex;
break;
}
}
AddSource(
movedItem->GetItemBaseInfo(),
POSTYPE(wEmptyPos));
AddResult(
movedItem->GetItemBaseInfo());
mSubmitButton->SetActive(
TRUE);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KeychainManagerAvailable
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KeychainManagerAvailable::COp_KeychainManagerAvailable()
:mAvailable("Available")
{
AddResult(mAvailable);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCGetKeychainManagerVersion
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCGetKeychainManagerVersion::COp_KCGetKeychainManagerVersion()
:mVersion("Version")
{
AddResult(mVersion);
}
BOOL CDissolveDialog::FakeMoveIcon(LONG x, LONG y, cIcon* movedIcon)
{
// 완료된 결과가 있을 경우 초기화시킨다
{
CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
0);
if(item->IsLocked())
{
Clear();
}
}
CItem* const movedItem = (CItem*)movedIcon;
if(0 == movedItem)
{
return FALSE;
}
else if(WT_ITEM != movedItem->GetType())
{
return FALSE;
}
else if(movedItem->IsLocked())
{
return FALSE;
}
else if(FALSE == ITEMMGR->IsEqualTableIdxForPos(eItemTable_Inventory, movedItem->GetPosition()))
{
CHATMGR->AddMsg(
CTC_SYSMSG,
CHATMGR->GetChatMsg(787));
return FALSE;
}
// 기존 아이템이 위치한 장소에 놓았을 경우 교체한다
const POINT point = {x, y};
CItem* const item = GetSourceItem(
point);
if(0 == item)
{
return FALSE;
}
else if(0 < item->GetItemIdx())
{
RemoveSource(
item->GetItemBaseInfo(),
POSTYPE(item->GetData()));
RemoveResult(
item->GetItemBaseInfo());
Clear(
*item);
}
const Error error = IsEnableUpdate(movedItem->GetItemBaseInfo());
if(ErrorNone != error)
{
PutError(
error,
movedItem->GetItemIdx());
return FALSE;
}
AddSource(
movedItem->GetItemBaseInfo(),
POSTYPE(item->GetData()));
AddResult(
movedItem->GetItemBaseInfo());
mSubmitButton->SetActive(
TRUE);
return FALSE;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCCopyItem
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCCopyItem::COp_KCCopyItem()
{
AddParam(mKeychainIndex);
AddParam(mItemIndex);
AddResult(mItemIndex);
}
double RangeSearchRules<MetricType, TreeType>::Score(TreeType& queryNode,
TreeType& referenceNode)
{
math::Range distances;
if (tree::TreeTraits<TreeType>::FirstPointIsCentroid)
{
// It is possible that the base case has already been calculated.
double baseCase = 0.0;
bool alreadyDone = false;
if (tree::TreeTraits<TreeType>::HasSelfChildren)
{
TreeType* lastQuery = (TreeType*) referenceNode.Stat().LastDistanceNode();
TreeType* lastRef = (TreeType*) queryNode.Stat().LastDistanceNode();
// Did the query node's last combination do the base case?
if ((lastRef != NULL) && (referenceNode.Point(0) == lastRef->Point(0)))
{
baseCase = queryNode.Stat().LastDistance();
alreadyDone = true;
}
// Did the reference node's last combination do the base case?
if ((lastQuery != NULL) && (queryNode.Point(0) == lastQuery->Point(0)))
{
baseCase = referenceNode.Stat().LastDistance();
alreadyDone = true;
}
// If the query node is a self-child, did the query parent's last
// combination do the base case?
if ((queryNode.Parent() != NULL) &&
(queryNode.Point(0) == queryNode.Parent()->Point(0)))
{
TreeType* lastParentRef = (TreeType*)
queryNode.Parent()->Stat().LastDistanceNode();
if ((lastParentRef != NULL) &&
(referenceNode.Point(0) == lastParentRef->Point(0)))
{
baseCase = queryNode.Parent()->Stat().LastDistance();
alreadyDone = true;
}
}
// If the reference node is a self-child, did the reference parent's last
// combination do the base case?
if ((referenceNode.Parent() != NULL) &&
(referenceNode.Point(0) == referenceNode.Parent()->Point(0)))
{
TreeType* lastQueryRef = (TreeType*)
referenceNode.Parent()->Stat().LastDistanceNode();
if ((lastQueryRef != NULL) &&
(queryNode.Point(0) == lastQueryRef->Point(0)))
{
baseCase = referenceNode.Parent()->Stat().LastDistance();
alreadyDone = true;
}
}
}
if (!alreadyDone)
{
// We must calculate the base case.
baseCase = BaseCase(queryNode.Point(0), referenceNode.Point(0));
}
else
{
// Make sure that if BaseCase() is called, we don't duplicate results.
lastQueryIndex = queryNode.Point(0);
lastReferenceIndex = referenceNode.Point(0);
}
distances.Lo() = baseCase - queryNode.FurthestDescendantDistance()
- referenceNode.FurthestDescendantDistance();
distances.Hi() = baseCase + queryNode.FurthestDescendantDistance()
+ referenceNode.FurthestDescendantDistance();
// Update the last distances performed for the query and reference node.
queryNode.Stat().LastDistanceNode() = (void*) &referenceNode;
queryNode.Stat().LastDistance() = baseCase;
referenceNode.Stat().LastDistanceNode() = (void*) &queryNode;
referenceNode.Stat().LastDistance() = baseCase;
}
else
{
// Just perform the calculation.
distances = referenceNode.RangeDistance(&queryNode);
}
// If the ranges do not overlap, prune this node.
if (!distances.Contains(range))
return DBL_MAX;
// In this case, all of the points in the reference node will be part of all
// the results for each point in the query node.
if ((distances.Lo() >= range.Lo()) && (distances.Hi() <= range.Hi()))
{
for (size_t i = 0; i < queryNode.NumDescendants(); ++i)
AddResult(queryNode.Descendant(i), referenceNode);
return DBL_MAX; // We don't need to go any deeper.
}
// Otherwise the score doesn't matter. Recursion order is irrelevant in range
// search.
return 0.0;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ COp_KCFindNextItem
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
COp_KCFindNextItem::COp_KCFindNextItem()
{
AddParam(mSearchIndex);
AddResult(mItemIndex);
}