explicit PriorityQueue(const _Compare& __comp = _Compare(),
const _Sequence& __s = _Sequence(),
const _Map& __m = _Map())
: c(__s), m(__m), comp(__comp)
{
make_heap(c.begin(), c.end(), comp);
}
static bool _Evaluate(
const WQLOperand& lhs,
const WQLOperand& rhs,
WQLOperation op)
{
switch (lhs.getType())
{
case WQLOperand::NULL_VALUE:
{
// return true if the op is WQL_EQ and the rhs is NULL
// also if op is WQL_NE and rhs is not NULL
return !(op == WQL_EQ) ^ (rhs.getType() == WQLOperand::NULL_VALUE);
break;
}
case WQLOperand::INTEGER_VALUE:
{
return _Compare(
lhs.getIntegerValue(),
rhs.getIntegerValue(),
op);
}
case WQLOperand::DOUBLE_VALUE:
{
return _Compare(
lhs.getDoubleValue(),
rhs.getDoubleValue(),
op);
}
case WQLOperand::BOOLEAN_VALUE:
{
return _Compare(
lhs.getBooleanValue(),
rhs.getBooleanValue(),
op);
}
case WQLOperand::STRING_VALUE:
{
return _Compare(
lhs.getStringValue(),
rhs.getStringValue(),
op);
}
default:
OW_ASSERT(0);
}
return false;
}
PriorityQueue(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Sequence& __s = _Sequence(),
const _Map& __m = _Map())
: c(__s), m(__m), comp(__comp)
{
c.insert(c.end(), __first, __last);
make_heap(c.begin(), c.end(), comp);
}
void* max(void* _First, void* _Second, int (*_Compare)(void*, void*))
{
/* if _First is less than _Second, return _Second */
if (_Compare(_First, _Second)) return _Second;
/* else return _First */
else return _First;
}
void* LnkLstSearch(struct LinkedList* _List, const void* _Data, int (*_Compare)(const void*, const void*)) {
struct LnkLst_Node* _Node = _List->Front;
while(_Node != NULL) {
if(_Compare(_Data, _Node->Data) == 0)
return _Node->Data;
_Node = _Node->Next;
}
return NULL;
}
/*********************************************************************
*
* _BubbleSort
*
* Purpose:
* Bubble sort algorithm.
*/
static void _BubbleSort(unsigned lb, unsigned ub, SORT_OBJECT * pSortObject) {
int Swapped;
do {
unsigned i;
Swapped = 0;
for (i = ub; i > lb; i--) {
if (_Compare(i - 1, i, pSortObject) > 0) {
_Swap(i - 1, i, pSortObject);
Swapped = 1;
}
}
} while (Swapped);
}
static Boolean _Evaluate(
const WQLOperand& lhs,
const WQLOperand& rhs,
WQLOperation op)
{
switch (lhs.getType())
{
case WQLOperand::NULL_VALUE:
{
#ifdef PEGASUS_SNIA_EXTENSIONS
return (rhs.getType() == WQLOperand::NULL_VALUE);
#else
// This cannot happen since expressions of the form
// OPERAND OPERATOR NULL are converted to unary form.
// For example: "count IS NULL" is treated as a unary
// operation in which IS_NULL is the unary operation
// and count is the the unary operand.
PEGASUS_ASSERT(0);
break;
#endif
}
case WQLOperand::INTEGER_VALUE:
{
return _Compare(
lhs.getIntegerValue(),
rhs.getIntegerValue(),
op);
}
case WQLOperand::DOUBLE_VALUE:
{
return _Compare(
lhs.getDoubleValue(),
rhs.getDoubleValue(),
op);
}
case WQLOperand::BOOLEAN_VALUE:
{
return _Compare(
lhs.getBooleanValue(),
rhs.getBooleanValue(),
op);
}
case WQLOperand::STRING_VALUE:
{
if(op != WQL_LIKE) {
return _Compare(
lhs.getStringValue(),
rhs.getStringValue(),
op);
}
else {
CString lhsstr = lhs.getStringValue().getCString();
CString rhsstr = rhs.getStringValue().getCString();
const char* lhscs = (const char *)lhsstr;
const char* rhscs = (const char *)rhsstr;
return _LikeEvaluate((const char *)lhsstr, (const char *)rhsstr);
}
}
default:
PEGASUS_ASSERT(0);
}
return false;
}
void MapGridCtrl::Sort(SortKey vertical, SortKey horizontal, bool vertical_direction, bool horizontal_direction)
{
if (m_maps.empty())
return;
// Always start by sorting on name, to get duplicate maps together.
SortKey keys[3] = {SortKey_Name, vertical, horizontal};
bool dirs[3] = {false, vertical_direction, horizontal_direction};
// This looks like common antipattern 'loop switch sequence', however here
// it's the best way I found to prevent duplication of the switch statement,
// which will probably require most (all?) changes and possibly grow big.
for (int i = 0; i < 3; ++i) {
// Do nothing if current sortkey is same as previous one.
if (i > 0 && keys[i] == keys[i - 1] && dirs[i] == dirs[i - 1])
continue;
// Sort dimension i on sortkey keys[i].
const bool d = dirs[i];
switch (keys[i]) {
case SortKey_Name:
_Sort(i, _Compare(d, CompareName));
break;
case SortKey_TidalStrength:
_Sort(i, _Compare(d, CompareTidalStrength));
break;
case SortKey_Gravity:
_Sort(i, _Compare(d, CompareGravity));
break;
case SortKey_MaxMetal:
_Sort(i, _Compare(d, CompareMaxMetal));
break;
case SortKey_ExtractorRadius:
_Sort(i, _Compare(d, CompareExtractorRadius));
break;
case SortKey_MinWind:
_Sort(i, _Compare(d, CompareMinWind));
break;
case SortKey_MaxWind:
_Sort(i, _Compare(d, CompareMaxWind));
break;
case SortKey_Wind:
_Sort(i, _Compare(d, CompareWind));
break;
case SortKey_Area:
_Sort(i, _Compare(d, CompareArea));
break;
case SortKey_AspectRatio:
_Sort(i, _Compare(d, CompareAspectRatio));
break;
case SortKey_PosCount:
_Sort(i, _Compare(d, ComparePosCount));
break;
default:
ASSERT_EXCEPTION(false, _T("unimplemented SortKey in MapGridCtrl::Sort"));
break;
}
}
}
HRESULT KG3DScenePvsEditor::ProcessMessage(UINT message, WPARAM wParam, LPARAM lParam)//<PROCESS_MESSAGE>
{
switch (message)
{
case WM_LBUTTONUP :
Place2Pvs();
break;
case WM_KEYDOWN :
{
switch (wParam)
{
case VK_SHIFT :
{
if (!m_bSwitchObj && m_listPlaceObj.size() > 0)
{
m_itorListObj = m_listPlaceObj.end();
--m_itorListObj;
}
m_bSwitchObj = true;
}
break;
case VK_TAB :
{
KG3DSceneSelectionTool& selTool = this->GetSelectionTool();
//if (m_listSelectedEntity.size() <= 0)
// break;
if(selTool.GetSelectionCount() <= 0)
break;
if (m_listSelTabEntity.size() == 0)
{
//KG3DSceneEntity frontEntity = m_listSelectedEntity.front();
selTool.GetSelectionAccessProxy().Begin();
KG3DSceneEntity frontEntity = selTool.GetSelectionAccessProxy().GetCur(); //注意前面做了选择非空的判断，不然这里是有问题的
//m_listSelTabEntity = m_listSelectableEntity;
/*2009-1-8 新的选择工具不支持直接复制内部的选择体，但是支持创建选择组。但是这里问题比较严重，因为需要sort，而选择
工具内部维护的选择表有自己的结构，不一定能支持sort，所以这里把选择表复制出来*/
selTool.GetSelectableList(m_listSelTabEntity);
m_listSelTabEntity.sort(_Compare(frontEntity));
m_itorTabSel = m_listSelTabEntity.begin();
}
if (++m_itorTabSel == m_listSelTabEntity.end())
m_itorTabSel = m_listSelTabEntity.begin();
//ClearSelectedEntity();
this->GetSelectionTool().ClearSelection();
//AddSelectedEntity(*m_itorTabSel);
this->GetSelectionTool().SetSelected(*m_itorTabSel, TRUE);
// switch (this->GetEditState())
// {
// //case SCENESTATE_MOVE :
////OnToggleStateMove();//<OnToggleStateMove Refactor>//SceneSelectBase会监视SetEditState，在内部改变状态
// // break;
// //case SCENESTATE_ROTATE :
// //OnToggleStateRotation();//<OnToggleStateRotation Refactor>//SceneSelectBase会监视SetEditState，在内部改变状态
// // break;
// /* case SCENESTATE_SCALE :
// OnToggleStateScaling();//<OnToggleStateScaling Refactor>//SceneSelectBase会监视SetEditState，在内部改变状态
// break;*/
// default :
// break;
// }
}
break;
default :
break;
}
}
break;
case WM_KEYUP :
{
switch (wParam)
{
case VK_SHIFT :
{
if (m_listPlaceObj.size() > MAX_PLACE_OBJ_HISTORY_SIZE)
{
list<string>::iterator ito = m_listPlaceObj.begin();
advance(ito, MAX_PLACE_OBJ_HISTORY_SIZE / 10);
m_listPlaceObj.erase(m_listPlaceObj.begin(), ito);
}
m_bSwitchObj = false;
}
break;
default :
break;
}
}
break;
case WM_MOUSEWHEEL :
{
short wheel = static_cast<short>(HIWORD(wParam));
if (m_bSwitchObj && m_listPlaceObj.size() > 0)
{
list<string>::iterator last = m_listPlaceObj.end();
--last;
if (wheel < 0 && m_itorListObj != last)
++m_itorListObj;
if (wheel > 0 && m_itorListObj != m_listPlaceObj.begin())
--m_itorListObj;
SetHandObject((*m_itorListObj).c_str());
}
if (m_bSwitchObj)
return S_OK;
}
break;
case WM_RBUTTONDOWN :
{
if (m_bRunMode && m_pRunder)
m_pRunder->ProcessRButtonDn(wParam, lParam);
}
break;
case WM_RBUTTONUP :
{
if (m_bRunMode && m_pRunder)
m_pRunder->ProcessRButtonUp(wParam, lParam);
}
break;
default :
break;
}
KG3DSceneEditorBase::ProcessMessage(message, wParam, lParam);
return S_OK;
}
